-
Notifications
You must be signed in to change notification settings - Fork 3.5k
/
DistanceDisplayCondition.js
172 lines (155 loc) · 5 KB
/
DistanceDisplayCondition.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
import defaultValue from "./defaultValue.js";
import defined from "./defined.js";
import DeveloperError from "./DeveloperError.js";
/**
* Determines visibility based on the distance to the camera.
*
* @alias DistanceDisplayCondition
* @constructor
*
* @param {Number} [near=0.0] The smallest distance in the interval where the object is visible.
* @param {Number} [far=Number.MAX_VALUE] The largest distance in the interval where the object is visible.
*
* @example
* // Make a billboard that is only visible when the distance to the camera is between 10 and 20 meters.
* billboard.distanceDisplayCondition = new Cesium.DistanceDisplayCondition(10.0, 20.0);
*/
function DistanceDisplayCondition(near, far) {
near = defaultValue(near, 0.0);
this._near = near;
far = defaultValue(far, Number.MAX_VALUE);
this._far = far;
}
Object.defineProperties(DistanceDisplayCondition.prototype, {
/**
* The smallest distance in the interval where the object is visible.
* @memberof DistanceDisplayCondition.prototype
* @type {Number}
* @default 0.0
*/
near: {
get: function () {
return this._near;
},
set: function (value) {
this._near = value;
},
},
/**
* The largest distance in the interval where the object is visible.
* @memberof DistanceDisplayCondition.prototype
* @type {Number}
* @default Number.MAX_VALUE
*/
far: {
get: function () {
return this._far;
},
set: function (value) {
this._far = value;
},
},
});
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
DistanceDisplayCondition.packedLength = 2;
/**
* Stores the provided instance into the provided array.
*
* @param {DistanceDisplayCondition} value The value to pack.
* @param {Number[]} array The array to pack into.
* @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
*
* @returns {Number[]} The array that was packed into
*/
DistanceDisplayCondition.pack = function (value, array, startingIndex) {
//>>includeStart('debug', pragmas.debug);
if (!defined(value)) {
throw new DeveloperError("value is required");
}
if (!defined(array)) {
throw new DeveloperError("array is required");
}
//>>includeEnd('debug');
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value.near;
array[startingIndex] = value.far;
return array;
};
/**
* Retrieves an instance from a packed array.
*
* @param {Number[]} array The packed array.
* @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
* @param {DistanceDisplayCondition} [result] The object into which to store the result.
* @returns {DistanceDisplayCondition} The modified result parameter or a new DistanceDisplayCondition instance if one was not provided.
*/
DistanceDisplayCondition.unpack = function (array, startingIndex, result) {
//>>includeStart('debug', pragmas.debug);
if (!defined(array)) {
throw new DeveloperError("array is required");
}
//>>includeEnd('debug');
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new DistanceDisplayCondition();
}
result.near = array[startingIndex++];
result.far = array[startingIndex];
return result;
};
/**
* Determines if two distance display conditions are equal.
*
* @param {DistanceDisplayCondition} left A distance display condition.
* @param {DistanceDisplayCondition} right Another distance display condition.
* @return {Boolean} Whether the two distance display conditions are equal.
*/
DistanceDisplayCondition.equals = function (left, right) {
return (
left === right ||
(defined(left) &&
defined(right) &&
left.near === right.near &&
left.far === right.far)
);
};
/**
* Duplicates a distance display condition instance.
*
* @param {DistanceDisplayCondition} [value] The distance display condition to duplicate.
* @param {DistanceDisplayCondition} [result] The result onto which to store the result.
* @return {DistanceDisplayCondition} The duplicated instance.
*/
DistanceDisplayCondition.clone = function (value, result) {
if (!defined(value)) {
return undefined;
}
if (!defined(result)) {
result = new DistanceDisplayCondition();
}
result.near = value.near;
result.far = value.far;
return result;
};
/**
* Duplicates this instance.
*
* @param {DistanceDisplayCondition} [result] The result onto which to store the result.
* @return {DistanceDisplayCondition} The duplicated instance.
*/
DistanceDisplayCondition.prototype.clone = function (result) {
return DistanceDisplayCondition.clone(this, result);
};
/**
* Determines if this distance display condition is equal to another.
*
* @param {DistanceDisplayCondition} other Another distance display condition.
* @return {Boolean} Whether this distance display condition is equal to the other.
*/
DistanceDisplayCondition.prototype.equals = function (other) {
return DistanceDisplayCondition.equals(this, other);
};
export default DistanceDisplayCondition;