Remove unused WebGL related code
This commit is contained in:
Éric Lemoine
@@ -1,10 +1,8 @@
|
||||
goog.provide('ol.structs.Buffer');
|
||||
|
||||
goog.require('goog.array');
|
||||
goog.require('goog.asserts');
|
||||
goog.require('goog.webgl');
|
||||
goog.require('ol');
|
||||
goog.require('ol.structs.IntegerSet');
|
||||
|
||||
|
||||
/**
|
||||
@@ -21,11 +19,10 @@ ol.structs.BufferUsage = {
|
||||
/**
|
||||
* @constructor
|
||||
* @param {Array.<number>=} opt_arr Array.
|
||||
* @param {number=} opt_used Used.
|
||||
* @param {number=} opt_usage Usage.
|
||||
* @struct
|
||||
*/
|
||||
ol.structs.Buffer = function(opt_arr, opt_used, opt_usage) {
|
||||
ol.structs.Buffer = function(opt_arr, opt_usage) {
|
||||
|
||||
/**
|
||||
* @private
|
||||
@@ -33,43 +30,6 @@ ol.structs.Buffer = function(opt_arr, opt_used, opt_usage) {
|
||||
*/
|
||||
this.arr_ = goog.isDef(opt_arr) ? opt_arr : [];
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Array.<ol.structs.IntegerSet>}
|
||||
*/
|
||||
this.dirtySets_ = [];
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {ol.structs.IntegerSet}
|
||||
*/
|
||||
this.freeSet_ = new ol.structs.IntegerSet();
|
||||
|
||||
var used = goog.isDef(opt_used) ? opt_used : this.arr_.length;
|
||||
if (used < this.arr_.length) {
|
||||
this.freeSet_.addRange(used, this.arr_.length);
|
||||
}
|
||||
if (ol.BUFFER_REPLACE_UNUSED_ENTRIES_WITH_NANS) {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var i;
|
||||
for (i = used; i < n; ++i) {
|
||||
arr[i] = NaN;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {?Float32Array}
|
||||
*/
|
||||
this.split32_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {ol.structs.IntegerSet}
|
||||
*/
|
||||
this.split32DirtySet_ = null;
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {number}
|
||||
@@ -80,56 +40,6 @@ ol.structs.Buffer = function(opt_arr, opt_used, opt_usage) {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} size Size.
|
||||
* @return {number} Offset.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.allocate = function(size) {
|
||||
goog.asserts.assert(size > 0);
|
||||
var offset = this.freeSet_.findRange(size);
|
||||
goog.asserts.assert(offset != -1); // FIXME
|
||||
this.freeSet_.removeRange(offset, offset + size);
|
||||
return offset;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {Array.<number>} values Values.
|
||||
* @return {number} Offset.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.add = function(values) {
|
||||
var size = values.length;
|
||||
var offset = this.allocate(size);
|
||||
var i;
|
||||
for (i = 0; i < size; ++i) {
|
||||
this.arr_[offset + i] = values[i];
|
||||
}
|
||||
this.markDirty(size, offset);
|
||||
return offset;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {ol.structs.IntegerSet} dirtySet Dirty set.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.addDirtySet = function(dirtySet) {
|
||||
goog.asserts.assert(!goog.array.contains(this.dirtySets_, dirtySet));
|
||||
this.dirtySets_.push(dirtySet);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {function(this: T, number, number)} f Callback.
|
||||
* @param {T=} opt_this The object to use as `this` in `f`.
|
||||
* @template T
|
||||
*/
|
||||
ol.structs.Buffer.prototype.forEachRange = function(f, opt_this) {
|
||||
if (this.arr_.length !== 0) {
|
||||
this.freeSet_.forEachRangeInverted(0, this.arr_.length, f, opt_this);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {Array.<number>} Array.
|
||||
*/
|
||||
@@ -138,120 +48,9 @@ ol.structs.Buffer.prototype.getArray = function() {
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {number} Count.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.getCount = function() {
|
||||
return this.arr_.length - this.freeSet_.getSize();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {ol.structs.IntegerSet} Free set.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.getFreeSet = function() {
|
||||
return this.freeSet_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Returns a Float32Array twice the length of the buffer containing each value
|
||||
* split into two 32-bit floating point values that, when added together,
|
||||
* approximate the original value. Even indicies contain the high bits, odd
|
||||
* indicies contain the low bits.
|
||||
* @see http://blogs.agi.com/insight3d/index.php/2008/09/03/precisions-precisions/
|
||||
* @return {Float32Array} Split.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.getSplit32 = function() {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
if (goog.isNull(this.split32DirtySet_)) {
|
||||
this.split32DirtySet_ = new ol.structs.IntegerSet([0, n]);
|
||||
this.addDirtySet(this.split32DirtySet_);
|
||||
}
|
||||
if (goog.isNull(this.split32_)) {
|
||||
this.split32_ = new Float32Array(2 * n);
|
||||
}
|
||||
var split32 = this.split32_;
|
||||
this.split32DirtySet_.forEachRange(function(start, stop) {
|
||||
var doubleHigh, i, j, value;
|
||||
for (i = start, j = 2 * start; i < stop; ++i, j += 2) {
|
||||
value = arr[i];
|
||||
if (value < 0) {
|
||||
doubleHigh = 65536 * Math.floor(-value / 65536);
|
||||
split32[j] = -doubleHigh;
|
||||
split32[j + 1] = value + doubleHigh;
|
||||
} else {
|
||||
doubleHigh = 65536 * Math.floor(value / 65536);
|
||||
split32[j] = doubleHigh;
|
||||
split32[j + 1] = value - doubleHigh;
|
||||
}
|
||||
}
|
||||
});
|
||||
this.split32DirtySet_.clear();
|
||||
return this.split32_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {number} Usage.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.getUsage = function() {
|
||||
return this.usage_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} size Size.
|
||||
* @param {number} offset Offset.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.markDirty = function(size, offset) {
|
||||
var i, ii;
|
||||
for (i = 0, ii = this.dirtySets_.length; i < ii; ++i) {
|
||||
this.dirtySets_[i].addRange(offset, offset + size);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} size Size.
|
||||
* @param {number} offset Offset.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.remove = function(size, offset) {
|
||||
var i, ii;
|
||||
this.freeSet_.addRange(offset, offset + size);
|
||||
for (i = 0, ii = this.dirtySets_.length; i < ii; ++i) {
|
||||
this.dirtySets_[i].removeRange(offset, offset + size);
|
||||
}
|
||||
if (ol.BUFFER_REPLACE_UNUSED_ENTRIES_WITH_NANS) {
|
||||
var arr = this.arr_;
|
||||
for (i = 0; i < size; ++i) {
|
||||
arr[offset + i] = NaN;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {ol.structs.IntegerSet} dirtySet Dirty set.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.removeDirtySet = function(dirtySet) {
|
||||
var removed = goog.array.remove(this.dirtySets_, dirtySet);
|
||||
goog.asserts.assert(removed);
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {Array.<number>} values Values.
|
||||
* @param {number} offset Offset.
|
||||
*/
|
||||
ol.structs.Buffer.prototype.set = function(values, offset) {
|
||||
var arr = this.arr_;
|
||||
var n = values.length;
|
||||
goog.asserts.assert(0 <= offset && offset + n <= arr.length);
|
||||
var i;
|
||||
for (i = 0; i < n; ++i) {
|
||||
arr[offset + i] = values[i];
|
||||
}
|
||||
this.markDirty(n, offset);
|
||||
};
|
||||
|
||||
@@ -1,330 +0,0 @@
|
||||
goog.provide('ol.structs.IntegerSet');
|
||||
|
||||
goog.require('goog.asserts');
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* A set of integers represented as a set of integer ranges.
|
||||
* This implementation is designed for the case when the number of distinct
|
||||
* integer ranges is small.
|
||||
* @constructor
|
||||
* @struct
|
||||
* @param {Array.<number>=} opt_arr Array.
|
||||
*/
|
||||
ol.structs.IntegerSet = function(opt_arr) {
|
||||
|
||||
/**
|
||||
* @private
|
||||
* @type {Array.<number>}
|
||||
*/
|
||||
this.arr_ = goog.isDef(opt_arr) ? opt_arr : [];
|
||||
|
||||
if (goog.DEBUG) {
|
||||
this.assertValid();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} addStart Start.
|
||||
* @param {number} addStop Stop.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.addRange = function(addStart, addStop) {
|
||||
goog.asserts.assert(addStart <= addStop);
|
||||
if (addStart == addStop) {
|
||||
return;
|
||||
}
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var i;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
if (addStart <= arr[i]) {
|
||||
// FIXME check if splice is really needed
|
||||
arr.splice(i, 0, addStart, addStop);
|
||||
this.compactRanges_();
|
||||
return;
|
||||
}
|
||||
}
|
||||
arr.push(addStart, addStop);
|
||||
this.compactRanges_();
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* FIXME empty description for jsdoc
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.assertValid = function() {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
goog.asserts.assert(n % 2 === 0);
|
||||
var i;
|
||||
for (i = 1; i < n; ++i) {
|
||||
goog.asserts.assert(arr[i] > arr[i - 1]);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* FIXME empty description for jsdoc
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.clear = function() {
|
||||
this.arr_.length = 0;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.compactRanges_ = function() {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var rangeIndex = 0;
|
||||
var i;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
if (arr[i] == arr[i + 1]) {
|
||||
// pass
|
||||
} else if (rangeIndex > 0 &&
|
||||
arr[rangeIndex - 2] <= arr[i] &&
|
||||
arr[i] <= arr[rangeIndex - 1]) {
|
||||
arr[rangeIndex - 1] = Math.max(arr[rangeIndex - 1], arr[i + 1]);
|
||||
} else {
|
||||
arr[rangeIndex++] = arr[i];
|
||||
arr[rangeIndex++] = arr[i + 1];
|
||||
}
|
||||
}
|
||||
arr.length = rangeIndex;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Finds the start of smallest range that is at least of length minSize, or -1
|
||||
* if no such range exists.
|
||||
* @param {number} minSize Minimum size.
|
||||
* @return {number} Index.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.findRange = function(minSize) {
|
||||
goog.asserts.assert(minSize > 0);
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var bestIndex = -1;
|
||||
var bestSize, i, size;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
size = arr[i + 1] - arr[i];
|
||||
if (size == minSize) {
|
||||
return arr[i];
|
||||
} else if (size > minSize && (bestIndex == -1 || size < bestSize)) {
|
||||
bestIndex = arr[i];
|
||||
bestSize = size;
|
||||
}
|
||||
}
|
||||
return bestIndex;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Calls f with each integer range.
|
||||
* @param {function(this: T, number, number)} f Callback.
|
||||
* @param {T=} opt_this The object to use as `this` in `f`.
|
||||
* @template T
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.forEachRange = function(f, opt_this) {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var i;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
f.call(opt_this, arr[i], arr[i + 1]);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Calls f with each integer range not in [start, stop) - 'this'.
|
||||
* @param {number} start Start.
|
||||
* @param {number} stop Stop.
|
||||
* @param {function(this: T, number, number)} f Callback.
|
||||
* @param {T=} opt_this The object to use as `this` in `f`.
|
||||
* @template T
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.forEachRangeInverted =
|
||||
function(start, stop, f, opt_this) {
|
||||
goog.asserts.assert(start < stop);
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
if (n === 0) {
|
||||
f.call(opt_this, start, stop);
|
||||
} else {
|
||||
if (start < arr[0]) {
|
||||
f.call(opt_this, start, arr[0]);
|
||||
}
|
||||
var i;
|
||||
for (i = 1; i < n - 1; i += 2) {
|
||||
f.call(opt_this, arr[i], arr[i + 1]);
|
||||
}
|
||||
if (arr[n - 1] < stop) {
|
||||
f.call(opt_this, arr[n - 1], stop);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {Array.<number>} Array.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.getArray = function() {
|
||||
return this.arr_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Returns the first element in the set, or -1 if the set is empty.
|
||||
* @return {number} Start.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.getFirst = function() {
|
||||
return this.arr_.length === 0 ? -1 : this.arr_[0];
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Returns the first integer after the last element in the set, or -1 if the
|
||||
* set is empty.
|
||||
* @return {number} Last.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.getLast = function() {
|
||||
var n = this.arr_.length;
|
||||
return n === 0 ? -1 : this.arr_[n - 1];
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* Returns the number of integers in the set.
|
||||
* @return {number} Size.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.getSize = function() {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var size = 0;
|
||||
var i;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
size += arr[i + 1] - arr[i];
|
||||
}
|
||||
return size;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} start Start.
|
||||
* @param {number} stop Stop.
|
||||
* @return {boolean} Intersects range.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.intersectsRange = function(start, stop) {
|
||||
goog.asserts.assert(start <= stop);
|
||||
if (start == stop) {
|
||||
return false;
|
||||
} else {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var i = 0;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
if (arr[i] <= start && start < arr[i + 1] ||
|
||||
arr[i] < stop && stop - 1 < arr[i + 1] ||
|
||||
start < arr[i] && arr[i + 1] <= stop) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {boolean} Is empty.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.isEmpty = function() {
|
||||
return this.arr_.length === 0;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @return {Array.<number>} Array.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.pack = function() {
|
||||
return this.arr_;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* @param {number} removeStart Start.
|
||||
* @param {number} removeStop Stop.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.removeRange =
|
||||
function(removeStart, removeStop) {
|
||||
// FIXME this could be more efficient
|
||||
goog.asserts.assert(removeStart <= removeStop);
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var i;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
if (removeStop < arr[i] || arr[i + 1] < removeStart) {
|
||||
continue;
|
||||
} else if (arr[i] > removeStop) {
|
||||
break;
|
||||
}
|
||||
if (removeStart < arr[i]) {
|
||||
if (removeStop == arr[i]) {
|
||||
break;
|
||||
} else if (removeStop < arr[i + 1]) {
|
||||
arr[i] = Math.max(arr[i], removeStop);
|
||||
break;
|
||||
} else {
|
||||
arr.splice(i, 2);
|
||||
i -= 2;
|
||||
n -= 2;
|
||||
}
|
||||
} else if (removeStart == arr[i]) {
|
||||
if (removeStop < arr[i + 1]) {
|
||||
arr[i] = removeStop;
|
||||
break;
|
||||
} else if (removeStop == arr[i + 1]) {
|
||||
arr.splice(i, 2);
|
||||
break;
|
||||
} else {
|
||||
arr.splice(i, 2);
|
||||
i -= 2;
|
||||
n -= 2;
|
||||
}
|
||||
} else {
|
||||
if (removeStop < arr[i + 1]) {
|
||||
arr.splice(i, 2, arr[i], removeStart, removeStop, arr[i + 1]);
|
||||
break;
|
||||
} else if (removeStop == arr[i + 1]) {
|
||||
arr[i + 1] = removeStart;
|
||||
break;
|
||||
} else {
|
||||
arr[i + 1] = removeStart;
|
||||
}
|
||||
}
|
||||
}
|
||||
this.compactRanges_();
|
||||
};
|
||||
|
||||
|
||||
if (goog.DEBUG) {
|
||||
|
||||
/**
|
||||
* @return {string} String.
|
||||
*/
|
||||
ol.structs.IntegerSet.prototype.toString = function() {
|
||||
var arr = this.arr_;
|
||||
var n = arr.length;
|
||||
var result = new Array(n / 2);
|
||||
var resultIndex = 0;
|
||||
var i;
|
||||
for (i = 0; i < n; i += 2) {
|
||||
result[resultIndex++] = arr[i] + '-' + arr[i + 1];
|
||||
}
|
||||
return result.join(', ');
|
||||
};
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user