code stringlengths 2 1.05M | repo_name stringlengths 5 114 | path stringlengths 4 991 | language stringclasses 1 value | license stringclasses 15 values | size int32 2 1.05M |
|---|---|---|---|---|---|
import alt from "alt-instance";
import WalletDb from "stores/WalletDb";
import AccountRefsStore from "stores/AccountRefsStore";
import AccountStore from "stores/AccountStore";
import BalanceClaimActiveStore from "stores/BalanceClaimActiveStore";
import CachedPropertyStore from "stores/CachedPropertyStore";
import PrivateKeyActions from "actions/PrivateKeyActions";
import WalletActions from "actions/WalletActions";
import {ChainStore} from "graphenejs-lib/es";
import BaseStore from "stores/BaseStore";
import iDB from "idb-instance";
import Immutable from "immutable";
/** High-level container for managing multiple wallets.
*/
class WalletManagerStore extends BaseStore {
constructor() {
super()
this.state = this._getInitialState()
this.bindListeners({
onRestore: WalletActions.restore,
onSetWallet: WalletActions.setWallet,
onSetBackupDate: WalletActions.setBackupDate,
onSetBrainkeyBackupDate: WalletActions.setBrainkeyBackupDate
})
super._export("init", "setNewWallet", "onDeleteWallet", "onDeleteAllWallets")
}
_getInitialState() {
return {
new_wallet: undefined,// pending restore
current_wallet: undefined,
wallet_names: Immutable.Set()
}
}
/** This will change the current wallet the newly restored wallet. */
onRestore({wallet_name, wallet_object}) {
iDB.restore(wallet_name, wallet_object).then( () => {
return this.onSetWallet({wallet_name})
}).catch( error => {
console.error(error)
return Promise.reject(error)
})
}
/** This may result in a new wallet name being added, only in this case
should a <b>create_wallet_password</b> be provided.
*/
onSetWallet({wallet_name = "default", create_wallet_password, brnkey, resolve}) {
var p = new Promise( resolve => {
if( /[^a-z0-9_-]/.test(wallet_name) || wallet_name === "" )
throw new Error("Invalid wallet name")
if(this.state.current_wallet === wallet_name) {
resolve()
return
}
var add
if( ! this.state.wallet_names.has(wallet_name) ) {
var wallet_names = this.state.wallet_names.add(wallet_name)
add = iDB.root.setProperty("wallet_names", wallet_names)
this.setState({wallet_names})
}
var current = iDB.root.setProperty("current_wallet", wallet_name)
resolve( Promise.all([ add, current ]).then(()=>{
// The database must be closed and re-opened first before the current
// application code can initialize its new state.
iDB.close()
ChainStore.clearCache()
BalanceClaimActiveStore.reset()
// Stores may reset when loadDbData is called
return iDB.init_instance().init_promise.then(()=>{
// Make sure the database is ready when calling CachedPropertyStore.reset()
CachedPropertyStore.reset()
return Promise.all([
WalletDb.loadDbData().then(()=>AccountStore.loadDbData()),
PrivateKeyActions.loadDbData().then(()=>AccountRefsStore.loadDbData())
]).then(()=>{
// Update state here again to make sure listeners re-render
if( ! create_wallet_password) {
this.setState({current_wallet: wallet_name})
return
}
return WalletDb.onCreateWallet(
create_wallet_password,
brnkey, //brainkey,
true, //unlock
wallet_name
).then(()=>
this.setState({current_wallet: wallet_name}))
})
})
}))
}).catch( error => {
console.error(error)
return Promise.reject(error)
})
if(resolve) resolve(p)
}
/** Used by the components during a pending wallet create. */
setNewWallet(new_wallet) {
this.setState({new_wallet})
}
init() {
return iDB.root.getProperty("current_wallet").then(
current_wallet => {
return iDB.root.getProperty("wallet_names", []).then( wallet_names => {
this.setState({
wallet_names: Immutable.Set(wallet_names),
current_wallet
})
})
})
}
onDeleteAllWallets() {
var deletes = []
this.state.wallet_names.forEach( wallet_name =>
deletes.push(this.onDeleteWallet(wallet_name)))
return Promise.all(deletes)
}
onDeleteWallet(delete_wallet_name) {
return new Promise( resolve => {
var {current_wallet, wallet_names} = this.state
if( ! wallet_names.has(delete_wallet_name) ) {
throw new Error("Can't delete wallet, does not exist in index")
}
wallet_names = wallet_names.delete(delete_wallet_name)
iDB.root.setProperty("wallet_names", wallet_names)
if(current_wallet === delete_wallet_name) {
current_wallet = wallet_names.size ? wallet_names.first() : undefined
iDB.root.setProperty("current_wallet", current_wallet)
}
this.setState({current_wallet, wallet_names})
var database_name = iDB.getDatabaseName(delete_wallet_name)
var req = iDB.impl.deleteDatabase(database_name)
resolve( database_name )
})
}
onSetBackupDate() {
WalletDb.setBackupDate()
}
onSetBrainkeyBackupDate() {
WalletDb.setBrainkeyBackupDate()
}
}
export var WalletManagerStoreWrapped = alt.createStore(WalletManagerStore, "WalletManagerStore");
export default WalletManagerStoreWrapped
| cryptonomex/graphene-ui | web/app/stores/WalletManagerStore.js | JavaScript | mit | 6,160 |
'use strict';
angular.module('ui.bootstrap', []); | chris-ramon/xims-web | test/client/mock/ui-bootstrap.js | JavaScript | mit | 51 |
// Create the gmap
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(25, 5), 2);
map.addControl(new GLargeMapControl());
map.addControl(new GMapTypeControl());
map.addControl(new GOverviewMapControl());
map.addControl(new GScaleControl());
map.enableDoubleClickZoom();
map.enableContinuousZoom();
// Create an icon
function createIcon(color) {
var icon = new GIcon();
icon.image = 'http://labs.google.com/ridefinder/images/mm_20_'+color+'.png';
icon.shadow = 'http://labs.google.com/ridefinder/images/mm_20_shadow.png';
icon.iconSize = new GSize(12, 20);
icon.shadowSize = new GSize(22, 20);
icon.iconAnchor = new GPoint(6, 20);
icon.infoWindowAnchor = new GPoint(5, 1);
return icon;
}
// Create a marker
function createMarker(point, infoTabs, icon) {
var marker = new GMarker(point, icon);
// Show this markers index in the info window when it is clicked
var html = infoTabs;
//GEvent.addListener(marker, 'click', function() {marker.openInfoWindowHtml(html);});// for only html
GEvent.addListener(marker, 'click', function() {marker.openInfoWindowTabsHtml(html);});// for infoTabs
return marker;
};
// Create an observer marker
function createObserverMarker(lon, lat, tab, color) {
var point = new GLatLng(lat, lon);
var infoTabs = [
tab
];
var marker = createMarker(point, infoTabs, createIcon(color));
return marker;
}
var observers = [];
observers.push( createObserverMarker(-121.86833333333,42.576666666667 , new GInfoWindowTab('Observer', 'Observer: WESLEY STONE<br/>Site: Chiloquin, OR'), 'red') );
observers.push( createObserverMarker(-113.7875,53.371111111111 , new GInfoWindowTab('Observer', 'Observer: BRUCE MCCURDY<br/>Site: Sanctuary Road'), 'red') );
observers.push( createObserverMarker(-112.78,53.536666666667 , new GInfoWindowTab('Observer', 'Observer: BRUCE MCCURDY<br/>Site: Beaver Hills DSP (Blackfoot)'), 'red') );
observers.push( createObserverMarker(-110.96166666667,29.104722222222 , new GInfoWindowTab('Observer', 'Observer: Salvador Aguirre<br/>Site: Hermosillo, Sonora'), 'red') );
observers.push( createObserverMarker(-110.82277777778,29.319444444444 , new GInfoWindowTab('Observer', 'Observer: Salvador Aguirre<br/>Site: Ejido El Carmen, Hermosillo, Sonora'), 'red') );
observers.push( createObserverMarker(-110.82277777778,29.319444444444 , new GInfoWindowTab('Observer', 'Observer: Salvador Aguirre<br/>Site: Ejido El Carmen, Hermosillo, Sonora '), 'red') );
observers.push( createObserverMarker(-89,38.666666666667 , new GInfoWindowTab('Observer', 'Observer: Peter Kozich<br/>Site: Greenville, IL'), 'red') );
observers.push( createObserverMarker(-82.354166666667,23.095 , new GInfoWindowTab('Observer', 'Observer: MARIANO GARCIA VILCHEZ<br/>Site: Lawton, 10 de Octubre, (Mileny's home)'), 'red') );
observers.push( createObserverMarker(-78.454166666667,43.116666666667 , new GInfoWindowTab('Observer', 'Observer: WILLIAM WATSON<br/>Site: Buffalo, New York'), 'red') );
observers.push( createObserverMarker(-76.983055555556,38.463888888889 , new GInfoWindowTab('Observer', 'Observer: RICHARD TAIBI<br/>Site: Bel Alton, Maryland'), 'red') );
observers.push( createObserverMarker(-75.830555555556,44.930555555556 , new GInfoWindowTab('Observer', 'Observer: PIERRE MARTIN<br/>Site: Merrickville'), 'red') );
observers.push( createObserverMarker(-75.611666666667,40.321666666667 , new GInfoWindowTab('Observer', 'Observer: Daniel Delaney<br/>Site: Gilbertsville'), 'red') );
observers.push( createObserverMarker(-75.091666666667,45.756944444444 , new GInfoWindowTab('Observer', 'Observer: PIERRE MARTIN<br/>Site: Bourget'), 'red') );
observers.push( createObserverMarker(-74.8983333333,40.6811111111 , new GInfoWindowTab('Observer', 'Observer: WAYNE T. HALLY<br/>Site: HIGH BRIDGE, NJ'), 'red') );
observers.push( createObserverMarker(-70.278611111111,-23.705833333333 , new GInfoWindowTab('Observer', 'Observer: Farid Char<br/>Site: Antofagasta'), 'red') );
observers.push( createObserverMarker(-17.876111111111,28.759444444444 , new GInfoWindowTab('Observer', 'Observer: FELIX BETTONVIL<br/>Site: Roque de los Muchachos, La Palma'), 'red') );
observers.push( createObserverMarker(-7.9,38.566666666667 , new GInfoWindowTab('Observer', 'Observer: MICHEL VANDEPUTTE<br/>Site: Evora'), 'red') );
observers.push( createObserverMarker(-7.75,38.833333333333 , new GInfoWindowTab('Observer', 'Observer: Koen Miskotte<br/>Site: Videnha (near Evora)'), 'red') );
observers.push( createObserverMarker(-7.75,38.833333333333 , new GInfoWindowTab('Observer', 'Observer: KOEN MISKOTTE<br/>Site: Videnha (near Evora)'), 'red') );
observers.push( createObserverMarker(-7.4,38.6 , new GInfoWindowTab('Observer', 'Observer: CARL JOHANNINK<br/>Site: Evora'), 'red') );
observers.push( createObserverMarker(-4.175,40.683333333333 , new GInfoWindowTab('Observer', 'Observer: FRANCISCO OCANA GONZALEZ<br/>Site: Peguerinos-Alto Leones'), 'red') );
observers.push( createObserverMarker(-2.8916666666667,40.096666666667 , new GInfoWindowTab('Observer', 'Observer: FRANCISCO OCANA GONZALEZ<br/>Site: Barajas de Melo - Huelves'), 'red') );
observers.push( createObserverMarker(-2.8916666666667,40.096666666667 , new GInfoWindowTab('Observer', 'Observer: Antonio Rodríguez Anaya<br/>Site: Huelves-Barajas de Melo'), 'red') );
observers.push( createObserverMarker(-0.683333333333,37.9666666667 , new GInfoWindowTab('Observer', 'Observer: RAFAEL RUBEN TORREGROSA SOLER<br/>Site: TORREVIEJA'), 'red') );
observers.push( createObserverMarker(5.4877777777778,51.704166666667 , new GInfoWindowTab('Observer', 'Observer: Joost Hartman<br/>Site: sterrenwacht Halley'), 'red') );
observers.push( createObserverMarker(5.4877777777778,51.704444444444 , new GInfoWindowTab('Observer', 'Observer: ROY KEERIS<br/>Site: Roy Keeris'), 'red') );
observers.push( createObserverMarker(5.86,52.205833333333 , new GInfoWindowTab('Observer', 'Observer: PETER VAN LEUTEREN<br/>Site: Veluwe'), 'red') );
observers.push( createObserverMarker(6.1511111111111,43.126666666667 , new GInfoWindowTab('Observer', 'Observer: JENS LACORNE<br/>Site: HYERES'), 'red') );
observers.push( createObserverMarker(6.4877777777778,52.23 , new GInfoWindowTab('Observer', 'Observer: PETER VAN LEUTEREN<br/>Site: Markelo'), 'red') );
observers.push( createObserverMarker(6.8677777777778,52.4225 , new GInfoWindowTab('Observer', 'Observer: SIETSE DIJKSTRA<br/>Site: Vasse'), 'red') );
observers.push( createObserverMarker(6.9661111111111,52.415 , new GInfoWindowTab('Observer', 'Observer: PETER VAN LEUTEREN<br/>Site: Cosmos Sterrenwacht Lattrop'), 'red') );
observers.push( createObserverMarker(6.9677777777778,52.415833333333 , new GInfoWindowTab('Observer', 'Observer: SIETSE DIJKSTRA<br/>Site: Cosmos publiekscentrum Lattrop'), 'red') );
observers.push( createObserverMarker(7.2661111111111,43.703333333333 , new GInfoWindowTab('Observer', 'Observer: COSTANTINO SIGISMONDI<br/>Site: Nice Av. Notre Dame/Rue Italie'), 'red') );
observers.push( createObserverMarker(7.2711111111111,43.694722222222 , new GInfoWindowTab('Observer', 'Observer: COSTANTINO SIGISMONDI<br/>Site: Nice Promenade des Anglais'), 'red') );
observers.push( createObserverMarker(9.95,49.833333333333 , new GInfoWindowTab('Observer', 'Observer: PIERRE BADER<br/>Site: Winterhausen'), 'red') );
observers.push( createObserverMarker(11.7166666667,48.55 , new GInfoWindowTab('Observer', 'Observer: SIRKO MOLAU<br/>Site: SEYSDORF'), 'red') );
observers.push( createObserverMarker(12.81,42.23 , new GInfoWindowTab('Observer', 'Observer: Roberto Haver<br/>Site: Frasso Sabino'), 'red') );
observers.push( createObserverMarker(12.816666666667,52.533333333333 , new GInfoWindowTab('Observer', 'Observer: RAINER ARLT<br/>Site: Tremmen'), 'red') );
observers.push( createObserverMarker(12.9638888889,52.4594444444 , new GInfoWindowTab('Observer', 'Observer: JURGEN RENDTEL<br/>Site: MARQUARDT'), 'red') );
observers.push( createObserverMarker(13.829166666667,45.56 , new GInfoWindowTab('Observer', 'Observer: JAVOR KAC<br/>Site: Tinjan'), 'red') );
observers.push( createObserverMarker(13.85,52.6666666667 , new GInfoWindowTab('Observer', 'Observer: FRANK ENZLEIN<br/>Site: TIEFENSEE'), 'red') );
observers.push( createObserverMarker(14.1166666667,52.2166666667 , new GInfoWindowTab('Observer', 'Observer: ANDRE KNOFEL<br/>Site: LINDENBERG'), 'red') );
observers.push( createObserverMarker(14.6,45.916666666667 , new GInfoWindowTab('Observer', 'Observer: JAVOR KAC<br/>Site: Vrh Nad Zelimljami'), 'red') );
observers.push( createObserverMarker(15.725833333333,50.035 , new GInfoWindowTab('Observer', 'Observer: VILEM HEBLIK<br/>Site: PARDUBICE'), 'red') );
observers.push( createObserverMarker(16.2688888889,46.3969444444 , new GInfoWindowTab('Observer', 'Observer: Mitja Govedic<br/>Site: SREDISCE OB DRAVI'), 'red') );
observers.push( createObserverMarker(17.101666666667,48.591111111111 , new GInfoWindowTab('Observer', 'Observer: JAKUB KOUKAL<br/>Site: Laksarska Nova Ves'), 'red') );
observers.push( createObserverMarker(17.396111111111,49.303888888889 , new GInfoWindowTab('Observer', 'Observer: Irena Divisova<br/>Site: Kromeriz'), 'red') );
observers.push( createObserverMarker(17.396111111111,49.303888888889 , new GInfoWindowTab('Observer', 'Observer: JAKUB KOUKAL<br/>Site: Kromeriz'), 'red') );
observers.push( createObserverMarker(17.396111111111,49.303888888889 , new GInfoWindowTab('Observer', 'Observer: SYLVIE GORKOVA<br/>Site: Kromeriz'), 'red') );
observers.push( createObserverMarker(17.5166666667,48.1 , new GInfoWindowTab('Observer', 'Observer: TIBOR CSORGEI<br/>Site: BELLOVA VES'), 'red') );
observers.push( createObserverMarker(20.75,53.0333333333 , new GInfoWindowTab('Observer', 'Observer: JAROSLAW DYGOS<br/>Site: CZERNICE BOROWE'), 'red') );
observers.push( createObserverMarker(23.7,47.966666666667 , new GInfoWindowTab('Observer', 'Observer: Arnold Gentz<br/>Site: Sapanta, Maramures'), 'red') );
observers.push( createObserverMarker(23.883333333333,47.933333333333 , new GInfoWindowTab('Observer', 'Observer: Sorin Hotea<br/>Site: Sighetu Marmatiei'), 'red') );
observers.push( createObserverMarker(26.635555555556,58.587222222222 , new GInfoWindowTab('Observer', 'Observer: Jaak Jaaniste<br/>Site: Raigastvere'), 'red') );
observers.push( createObserverMarker(35.103055555556,30.288055555556 , new GInfoWindowTab('Observer', 'Observer: ANNA S. LEVINA<br/>Site: Km101 (Be'er Menucha)'), 'red') );
observers.push( createObserverMarker(35.103055555556,30.288055555556 , new GInfoWindowTab('Observer', 'Observer: SHLOMI EINI<br/>Site: Km101 (Be'er Menucha)'), 'red') );
observers.push( createObserverMarker(35.103055555556,30.288055555556 , new GInfoWindowTab('Observer', 'Observer: SHY HALATZI<br/>Site: Km101 (Be'er Menucha)'), 'red') );
observers.push( createObserverMarker(35.133333333333,30.308333333333 , new GInfoWindowTab('Observer', 'Observer: Maria Eriksson<br/>Site: Km101 (Be'er Menucha)'), 'red') );
observers.push( createObserverMarker(35.133333333333,30.308333333333 , new GInfoWindowTab('Observer', 'Observer: SHLOMI EINI<br/>Site: Km101 (Be'er Menucha)'), 'red') );
observers.push( createObserverMarker(35.166666666667,30.483333333333 , new GInfoWindowTab('Observer', 'Observer: ANNA S. LEVINA<br/>Site: Be'er Manucha'), 'red') );
observers.push( createObserverMarker(37.108888888889,31.71 , new GInfoWindowTab('Observer', 'Observer: SAMER DERBI<br/>Site: al-azraq'), 'red') );
observers.push( createObserverMarker(37.108888888889,31.71 , new GInfoWindowTab('Observer', 'Observer: tareq bdran<br/>Site: Al-Azraq'), 'red') );
observers.push( createObserverMarker(39.3375,51.641666666667 , new GInfoWindowTab('Observer', 'Observer: Alexey Berezhnoy<br/>Site: Alexey Berezhnoy'), 'red') );
observers.push( createObserverMarker(51.799444444444,34.294166666667 , new GInfoWindowTab('Observer', 'Observer: ARASH NABIZADEH<br/>Site: Maranjab Desert, Aran & Bid Gol'), 'red') );
observers.push( createObserverMarker(52.738888888889,35.26 , new GInfoWindowTab('Observer', 'Observer: Mohammad Nilforoushan<br/>Site: Deh Namak Caravansary'), 'red') );
observers.push( createObserverMarker(72.711944444444,18.498611111111 , new GInfoWindowTab('Observer', 'Observer: AMOL KANKARIYA<br/>Site: PIRANGUTE'), 'red') );
observers.push( createObserverMarker(72.8,19.35 , new GInfoWindowTab('Observer', 'Observer: ASHVINI GHADIGAVKAR<br/>Site: VASAI'), 'red') );
observers.push( createObserverMarker(72.904166666667,19.386944444444 , new GInfoWindowTab('Observer', 'Observer: Vimal Mamania<br/>Site: Vegaclub (Chinchoti)'), 'red') );
observers.push( createObserverMarker(73.153055555556,22.304444444444 , new GInfoWindowTab('Observer', 'Observer: Shyamal Patel<br/>Site: Vadodara'), 'red') );
observers.push( createObserverMarker(73.299166666667,19.256666666667 , new GInfoWindowTab('Observer', 'Observer: Rohan Shewale<br/>Site: Mamnoli'), 'red') );
observers.push( createObserverMarker(73.299166666667,19.256666666667 , new GInfoWindowTab('Observer', 'Observer: SHISHIR DESHMUKH<br/>Site: Mamnoli'), 'red') );
observers.push( createObserverMarker(73.3333333333,22.25 , new GInfoWindowTab('Observer', 'Observer: SARTHAK DASADIA<br/>Site: MASTUPURA, GUJARAT'), 'red') );
observers.push( createObserverMarker(73.5,18.5 , new GInfoWindowTab('Observer', 'Observer: TUSHAR PUROHIT<br/>Site: PIRANGUTE'), 'red') );
observers.push( createObserverMarker(73.741944444444,18.554722222222 , new GInfoWindowTab('Observer', 'Observer: Shrikant Vinchurkar<br/>Site: PIRANGUT,PUNE'), 'red') );
observers.push( createObserverMarker(73.966666666667,18.566666666667 , new GInfoWindowTab('Observer', 'Observer: Rushikesh Tilak<br/>Site: Sinhagad, Pune'), 'red') );
observers.push( createObserverMarker(76.383333333333,27.383333333333 , new GInfoWindowTab('Observer', 'Observer: Amitabh Pandey (S.P.A.C.E.)<br/>Site: Sariska'), 'red') );
observers.push( createObserverMarker(76.383333333333,27.383333333333 , new GInfoWindowTab('Observer', 'Observer: Gunjan Bansal<br/>Site: Sariska'), 'red') );
observers.push( createObserverMarker(76.633333333333,27.633333333333 , new GInfoWindowTab('Observer', 'Observer: Akshay Gupta<br/>Site: sariska'), 'red') );
observers.push( createObserverMarker(77.25,28.616666666667 , new GInfoWindowTab('Observer', 'Observer: chander devgun SPACE<br/>Site: NEW DELHI'), 'red') );
observers.push( createObserverMarker(82.95,54.95 , new GInfoWindowTab('Observer', 'Observer: Mikhail Maslov<br/>Site: Novosibirsk'), 'red') );
observers.push( createObserverMarker(87.1780555556,43.4708333333 , new GInfoWindowTab('Observer', 'Observer: Jiangping Wu<br/>Site: URUMQI OBS., XINJIAN'), 'red') );
observers.push( createObserverMarker(87.1780555556,43.4708333333 , new GInfoWindowTab('Observer', 'Observer: Yue Hu<br/>Site: URUMQI OBS., XINJIAN'), 'red') );
observers.push( createObserverMarker(87.1780555556,43.4708333333 , new GInfoWindowTab('Observer', 'Observer: Zhongyang Hu<br/>Site: URUMQI OBS., XINJIAN'), 'red') );
observers.push( createObserverMarker(100.3325,14.025277777778 , new GInfoWindowTab('Observer', 'Observer: SUPARERK PANAROT<br/>Site: Ladluamkaew Patumtanee'), 'red') );
observers.push( createObserverMarker(112.46666666667,27.766666666667 , new GInfoWindowTab('Observer', 'Observer: Quanzhi Ye<br/>Site: Gaocun, Foshan'), 'red') );
observers.push( createObserverMarker(113.26666666667,23.066666666667 , new GInfoWindowTab('Observer', 'Observer: Quanzhi Ye<br/>Site: Higher Education Mega Center, Guangzhou'), 'red') );
observers.push( createObserverMarker(113.91666666667,38.05 , new GInfoWindowTab('Observer', 'Observer: GE Wei<br/>Site: Wei GE'), 'red') );
observers.push( createObserverMarker(115.49916666667,38.494722222222 , new GInfoWindowTab('Observer', 'Observer: hao wu<br/>Site: TanZhuang'), 'red') );
observers.push( createObserverMarker(115.71694444444,40.317777777778 , new GInfoWindowTab('Observer', 'Observer: Xiang ZHAN<br/>Site: Xiaonanxinpu, Yanqing, Beijing'), 'red') );
observers.push( createObserverMarker(115.93416666667,40.201111111111 , new GInfoWindowTab('Observer', 'Observer: Xiang ZHAN<br/>Site: Hezijian, Changping, Beijing'), 'red') );
observers.push( createObserverMarker(116.19444444444,40.334166666667 , new GInfoWindowTab('Observer', 'Observer: Sihao Cheng<br/>Site: Mayufang,Changping,Beijing'), 'red') );
observers.push( createObserverMarker(116.19444444444,40.334166666667 , new GInfoWindowTab('Observer', 'Observer: Simiao CHENG<br/>Site: Mayufang,Changping,Beijing'), 'red') );
observers.push( createObserverMarker(116.82916666667,40.553888888889 , new GInfoWindowTab('Observer', 'Observer: su zou<br/>Site: shitanglu,miyun,beijing'), 'red') );
observers.push( createObserverMarker(116.925,39.145277777778 , new GInfoWindowTab('Observer', 'Observer: Di Ma<br/>Site: DaLiutan,TianJin'), 'red') );
observers.push( createObserverMarker(117.15555555556,39.186388888889 , new GInfoWindowTab('Observer', 'Observer: Zhong Yang<br/>Site: Zhong Yang'), 'red') );
observers.push( createObserverMarker(119.59472222222,30.469444444444 , new GInfoWindowTab('Observer', 'Observer: Jiaqing Yang<br/>Site: Tianhuangping'), 'red') );
observers.push( createObserverMarker(120.87361111111,23.468611111111 , new GInfoWindowTab('Observer', 'Observer: Quanzhi Ye<br/>Site: Lulin Observatory'), 'red') );
observers.push( createObserverMarker(121.96638888889,30.94 , new GInfoWindowTab('Observer', 'Observer: LiYang Yu<br/>Site: Donghai Shanghai'), 'red') );
observers.push( createObserverMarker(121.96638888889,30.94 , new GInfoWindowTab('Observer', 'Observer: TengHuiRui Qu<br/>Site: Donghai Shanghai'), 'red') );
observers.push( createObserverMarker(122.07833333333,37.529722222222 , new GInfoWindowTab('Observer', 'Observer: Hao Zhou<br/>Site: Weihai,Shandong,China'), 'red') );
observers.push( createObserverMarker(125.58333333333,43.9925 , new GInfoWindowTab('Observer', 'Observer: Jia Wei MA Jia Wei MA<br/>Site: Jia Wei MA'), 'red') );
observers.push( createObserverMarker(140.10555555556,36.230555555556 , new GInfoWindowTab('Observer', 'Observer: SHIGEO UCHIYAMA<br/>Site: Sakuragawa, Ibaraki'), 'red') );
observers.push( createObserverMarker(144.33333333333,-35.8 , new GInfoWindowTab('Observer', 'Observer: ADAM MARSH<br/>Site: EAMN Home Base'), 'red') );
observers.push( createObserverMarker(144.33333333333,-35.8 , new GInfoWindowTab('Observer', 'Observer: LANCE KELLY<br/>Site: EAMN Home Base'), 'red') );
observers.push( createObserverMarker(144.58333333333,-35.816666666667 , new GInfoWindowTab('Observer', 'Observer: GEOFF CARSTAIRS<br/>Site: EAMN Home Base'), 'red') );
var mgr = new GMarkerManager(map);
mgr.addMarkers(observers, 0);
mgr.refresh(); | barentsen/imo-zhr-quicklooks | output/geminids2007/out/gem2007_gmap.js | JavaScript | mit | 18,788 |
// libraries
import { createStore, applyMiddleware, compose } from 'redux';
import thunkMiddleware from 'redux-thunk';
// portfolio
import rootReducer from '../reducers';
const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
export default function configureStore(preloadedState) {
const store = createStore(
rootReducer,
preloadedState,
composeEnhancers(
applyMiddleware(thunkMiddleware)
)
);
return store;
}
| Neablis/react-redux-starter | src/client/app/store/configure-store.js | JavaScript | mit | 469 |
/*!
* Angular Material Design
* https://github.com/angular/material
* @license MIT
* v0.11.4-master-ae00a7f
*/
goog.provide('ng.material.components.whiteframe');
/**
* @ngdoc module
* @name material.components.whiteframe
*/
angular.module('material.components.whiteframe', []);
ng.material.components.whiteframe = angular.module("material.components.whiteframe"); | ChrisYounger/MyLifeMetrics | website/bower_components/angular-material/modules/closure/whiteframe/whiteframe.js | JavaScript | mit | 373 |
import CalendarViewDateButton from 'ember-material-ui-datetime-picker/calendar-view-date-button';
export default CalendarViewDateButton;
| whalerock/ember-material-ui-datetime-picker | app/components/ember-material-ui-datetime-picker-calendar-view-date-button.js | JavaScript | mit | 138 |
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var _ = require('lodash');
var DoubleConverter = /** @class */ (function () {
function DoubleConverter() {
}
DoubleConverter.toNullableDouble = function (value) {
if (value == null)
return null;
if (_.isNumber(value))
return value;
if (_.isDate(value))
return value.getTime();
if (_.isBoolean(value))
return value ? 1 : 0;
var result = parseFloat(value);
return isNaN(result) ? null : result;
};
DoubleConverter.toDouble = function (value) {
return DoubleConverter.toDoubleWithDefault(value, 0);
};
DoubleConverter.toDoubleWithDefault = function (value, defaultValue) {
if (defaultValue === void 0) { defaultValue = 0; }
var result = DoubleConverter.toNullableDouble(value);
return result != null ? result : defaultValue;
};
return DoubleConverter;
}());
exports.DoubleConverter = DoubleConverter;
//# sourceMappingURL=DoubleConverter.js.map | pip-services/pip-services-commons-node | obj/src/convert/DoubleConverter.js | JavaScript | mit | 1,082 |
import React from 'react';
import {storiesOf} from '@kadira/storybook';
import {Board} from '../src';
const data = require('./data.json');
storiesOf('react-trello', module)
.addWithInfo('Full Board example',
'A complete Trello board with multiple lanes fed as json data',
() => (
<Board data={data}/>
));
| washswat/react-trello | stories/Base.story.js | JavaScript | mit | 329 |
(function () {
'use strict';
//Configuration of paths and variables to be used in all gulp tasks file
var gutil = require('gulp-util');
exports.paths = {
src: 'src',
dist: 'www',
tmp: '.tmp',
e2e: 'e2e',
docs: 'docs',
deploy: 'deploy',
js: [
'src/**/*.js',
'!src/**/*.specs.js'
],
scss: 'src/app/*.scss',
html: 'src/**/*.html'
};
exports.wiredep = {
directory: 'bower_components'
};
exports.errorHandler = function (title) {
return function (err) {
gutil.log(gutil.colors.red('[' + title + ']'), err.toString());
this.emit('end');
}
}
})();
| adi3230/redarmy | gulp/conf.js | JavaScript | mit | 687 |
const expect = require('chai').expect;
const InspireTree = require('../../../' + (process.env.DIST ? 'dist' : 'build') + '/inspire-tree');
describe('TreeNodes extends Array.prototype.reduceRight', function() {
let tree;
before(function() {
// Create tree
tree = new InspireTree({
data: [{
text: 'A'
}, {
text: 'B'
}, {
text: 'C'
}]
});
});
it('exists', function() {
expect(tree.nodes().reduceRight).to.be.a('function');
expect(tree.reduceRight).to.be.a('function');
});
it('right-reduces nodes to an array of text', function() {
const res = tree.nodes().reduceRight(function(a, b) {
a.push(b.text);
return a;
}, []);
expect(res).to.have.length(3);
expect(res[0]).to.equal('C');
expect(res[1]).to.equal('B');
expect(res[2]).to.equal('A');
});
});
| helion3/inspire-tree | test/treenodes/array/reduceRight.spec.js | JavaScript | mit | 988 |
import Ember from 'ember';
import XSelectComponent from './x-select';
var isArray = Ember.isArray;
/**
* Used to wrap a native `<option>` tag and associate an object with
* it that can be bound. It can only be used in conjuction with a
* containing `x-select` component
*
* @class Ember.XOptionComponent
* @extends Ember.Component
*/
export default Ember.Component.extend({
tagName: 'option',
attributeBindings: ['selected', 'name', 'disabled', 'value', 'title'],
classNameBindings: [':x-option'],
/**
* The value associated with this option. When this option is
* selected, the `x-select` will fire its action with this
* value.
*
* @property value
* @type Object
* @default null
*/
value: null,
/**
* Property bound to the `selected` attribute of the native
* `<option>` element. It is aware of the containing `x-select`'s
* value and will mark itself if it is the same.
*
* @private
* @property selected
* @type Boolean
*/
selected: Ember.computed('value', 'select.value', 'select.multiple', function() {
if (this.get('select.multiple') && isArray(this.get('select.value'))) {
let selectValue = Ember.A(this.get('select.value'));
return selectValue.contains(this.get('value'));
} else {
return this.get('value') === this.get('select.value');
}
}),
/**
* Register this x-option with the containing `x-select`
*
* @override
*/
didInsertElement: function() {
this._super.apply(this, arguments);
Ember.run.scheduleOnce('afterRender', () => {
var select = this.nearestOfType(XSelectComponent);
Ember.assert("x-option component declared without enclosing x-select", !!select);
this.set('select', select);
select.registerOption(this);
});
},
/**
* Unregister this x-option with its containing x-select.
*
* @override
*/
willDestroyElement: function() {
this._super.apply(this, arguments);
this.get('select').unregisterOption(this);
}
});
| knownasilya/emberx-select | addon/components/x-option.js | JavaScript | mit | 2,023 |
/*global define */
define([
'sandbox!code',
'app/code/viewmodels/codeViewModel',
'bindings!code',
'views!code',
'styles!code'
], function (
sandbox,
codeViewModel
) {
'use strict';
return function codeModule() {
var // imports
gridTemplate = sandbox.layout.utils.gridTemplate,
template = sandbox.mvvm.template,
registerStates = sandbox.state.registerStates,
registerTransition = sandbox.state.registerTransition,
state = sandbox.state.builder.state,
onEntry = sandbox.state.builder.onEntry,
on = sandbox.state.builder.on,
gotoInternally = sandbox.state.builder.gotoInternally,
has = sandbox.object.has,
// vars
code = codeViewModel(sandbox);
// Register application state for the module.
registerStates('app',
state('code',
onEntry(function () {
// Render and layout the code_template in the code module
this.code(gridTemplate('code_template', code));
}),
on('open.module', gotoInternally('load.module')),
state('load.module',
onEntry(function (e) {
var module = has(e) ? e.data.module : 'main';
code.load(module);
}))));
// Register state on the main module
registerStates('main',
state('code.module',
onEntry(function () {
this.module(template('code_module_template', code));
})));
// Register self-opening transition
registerTransition('main', on('open.module',
function (e) {
return e.data.module === 'code';
}, gotoInternally('code.module')));
};
});
| egucciar/learn.scalejs | app/code/codeModule.js | JavaScript | mit | 1,899 |
import { window } from '@angular/platform-browser/src/facade/browser';
import { Json } from '@angular/platform-browser/src/facade/lang';
const storageAvailable = (type) => {
try {
const storage = window[type];
const test = '__storage_test__';
storage.setItem(test, test);
storage.removeItem(test);
return true;
}
catch(e) {
return false;
}
};
const buildProxy = (type, { prefix, serialize }) => {
const service = window[type];
const proxyData = {
get: (target, key) => {
// || null to prevent undefined errors
return serialize.parse(target[`${prefix}-${key}`] || null);
},
set: (target, key, value) => {
return target[`${prefix}-${key}`] = serialize.stringify(value);
}
};
return new Proxy(service, proxyData);
};
export class StorageSettings {
constructor() {}
}
export class StorageService {
static get parameters() {
return [[StorageSettings]];
}
constructor(storageSettings) {
this.storageSettings = Object.assign({ prefix: 'ng2-storage', serialize: Json }, storageSettings);
if(typeof this.storageSettings.prefix === 'undefined') {
throw new Error('storageSettings.prefix must be a string');
}
if(!this.storageSettings.serialize) {
throw new Error('storageSettings.serialize must be an object { stringify, parse }');
}
if(typeof this.storageSettings.serialize.stringify !== 'function') {
throw new Error('storageSettings.serialize.stringify must be a function');
}
if(typeof this.storageSettings.serialize.parse !== 'function') {
throw new Error('storageSettings.serialize.parse must be a function');
}
if(!storageAvailable('localStorage')) {
console.warn('localStorage is not available!');
} else {
this.local = buildProxy('localStorage', this.storageSettings);
}
if(!storageAvailable('sessionStorage')) {
console.warn('sessionStorage is not available!');
} else {
this.session = buildProxy('sessionStorage', this.storageSettings);
}
}
}
| rdonalson/General-Testing | Angular2Testing/node_modules/ng2-storage/src/index.js | JavaScript | mit | 2,059 |
import classic from 'ember-classic-decorator';
import { classNames } from '@ember-decorators/component';
import { computed } from '@ember/object';
import { inject as service } from '@ember/service';
import { readOnly, max, mapBy, gt } from '@ember/object/computed';
import Component from '@ember/component';
import { copy } from '@ember/object/internals';
import { isEmpty } from '@ember/utils';
@classic
@classNames('evaluation-summary')
export default class PollEvaluationSummary extends Component {
@service
intl;
@computed('users.[]')
get bestOptions() {
// can not evaluate answer type free text
if (this.get('poll.isFreeText')) {
return undefined;
}
// can not evaluate a poll without users
if (isEmpty(this.users)) {
return undefined;
}
let answers = this.poll.answers.reduce((answers, answer) => {
answers[answer.get('type')] = 0;
return answers;
}, {});
let evaluation = this.poll.options.map((option) => {
return {
answers: copy(answers),
option,
score: 0
};
});
let bestOptions = [];
this.users.forEach((user) => {
user.selections.forEach(({ type }, i) => {
evaluation[i].answers[type]++;
switch (type) {
case 'yes':
evaluation[i].score += 2;
break;
case 'maybe':
evaluation[i].score += 1;
break;
case 'no':
evaluation[i].score -= 2;
break;
}
});
});
evaluation.sort((a, b) => b.score - a.score);
let bestScore = evaluation[0].score;
for (let i = 0; i < evaluation.length; i++) {
if (
bestScore === evaluation[i].score
) {
bestOptions.push(
evaluation[i]
);
} else {
break;
}
}
return bestOptions;
}
@readOnly('intl.primaryLocale')
currentLocale;
@gt('bestOptions.length', 1)
multipleBestOptions;
@max('participationDates')
lastParticipationAt;
@mapBy('users', 'creationDate')
participationDates;
@readOnly('users.length')
participantsCount;
@readOnly('poll.users')
users;
}
| jelhan/croodle | app/components/poll-evaluation-summary.js | JavaScript | mit | 2,173 |
'use strict';
(function() {
var Joi = require('joi');
module.exports = {
_id: Joi.string().optional(),
_rev: Joi.string().optional(),
permission: Joi.string().required().valid('ADMIN', 'USER'),
name: Joi.string().required(),
cpf: Joi.string().optional(),
rg: Joi.string().optional(),
endereco: Joi.array().items(Joi.object().keys({
criado: Joi.number().required(),
cep: Joi.number().required(),
logradouro: Joi.string().required(),
numero: Joi.number().required(),
bairro: Joi.string().required(),
cidade: Joi.string().required(),
uf: Joi.string().max(2).required()
})),
email: Joi.string().email().required(),
password: Joi.string().required(),
type: Joi.string().optional(),
_deleted: Joi.boolean().optional()
};
})();
| FFNascimento/sportsnow | features/users/userSchema.js | JavaScript | mit | 914 |
'use strict';
describe('vet edit page', function() {
var page;
beforeEach(function() {
var mockModule = require('./vet.mocks');
browser.addMockModule('httpBackendMock', mockModule );
browser.get('/#/app/vet/edit/1');
page = require('./vet.edit.po');
});
afterEach(function() {
browser.clearMockModules();
});
it('should contain all fields.', function() {
expect(page.firstNameEl).not.toBeNull()
expect(page.lastNameEl).not.toBeNull()
//expect(page.specialitiesEl).not.toBeNull()
});
});
| MayGo/grails-scaffold-demo | scafmo/angular/e2e/vet/vet.edit.spec.js | JavaScript | mit | 525 |
/**
* @file batchconsumerbatchproducer.js
* @brief Batch consumer - Batch producer step
* @author Frédéric SCHERMA (INRA UMR1095)
* @date 2017-12-19
* @copyright Copyright (c) 2017 INRA/CIRAD
* @license MIT (see LICENSE file)
* @details
*/
let ActionStepFormat = require('./actionstepformat');
let Marionette = require('backbone.marionette');
let Format = function() {
ActionStepFormat.call(this);
this.name = "batchconsumer_batchproducer";
this.group = "standard";
this.description = _t("Take a list of batches in input, and generate one or many batch in outputs.");
this.acceptFormat = ['batch_id'];
this.dataFormat = ['batch_id'];
};
_.extend(Format.prototype, ActionStepFormat.prototype, {
defaultFormat: function() {
return {};
}
});
Format.ActionStepProcessView = ActionStepFormat.ActionStepProcessView.extend({
className: 'action-step-process',
template: require('../templates/actionstep/process/batchconsumerbatchproducer.html'),
initialize: function(options) {
options || (options = {readonly: true});
this.listenTo(this.model, 'change', this.render, this);
},
onRender: function() {
if (this.getOption('readonly')) {
} else {
}
},
onBeforeDestroy: function() {
if (!this.getOption('readonly')) {
}
},
exportInput: function() {
},
importData: function() {
},
inputsType: function() {
return 'none';
},
inputsData: function() {
return null;
}
});
Format.ActionStepReadView = ActionStepFormat.ActionStepReadView.extend({
});
Format.ActionStepFormatDetailsView = ActionStepFormat.ActionStepFormatDetailsView.extend({
className: 'action-step-format-details',
template: require('../templates/actionstep/type/batchconsumerbatchproducer.html'),
initialize: function() {
this.listenTo(this.model, 'change', this.render, this);
},
onRender: function() {
let format = this.model.get('format');
},
storeData: function() {
return {
}
}
});
module.exports = Format;
| coll-gate/collgate | client/apps/accession/actionstep/batchconsumerbatchproducer.js | JavaScript | mit | 2,136 |
import {
GraphQLString,
GraphQLObjectType as ObjectType,
GraphQLID,
GraphQLNonNull,
} from 'graphql';
/* eslint-disable import/no-cycle */
import ProposalType from './ProposalDLType';
/* eslint-enable import/no-cycle */
import GraphQLDate from './GraphQLDateType';
import Proposal from '../models/Proposal';
const ProposalStatusType = new ObjectType({
name: 'ProposalStatus',
fields: {
id: {
type: new GraphQLNonNull(GraphQLID),
},
proposal: {
type: ProposalType,
resolve: async (data, args, { viewer, loaders }) => {
const proposal = await Proposal.gen(viewer, data.proposal_id, loaders);
if (proposal.deletedAt) {
return { id: proposal.id, deletedAt: proposal.deletedAt };
}
return proposal;
},
},
state: {
type: GraphQLString,
},
groupId: {
type: GraphQLID,
resolve: data => data.group_id,
},
groupType: {
type: GraphQLString,
resolve: data => data.group_type,
},
createdAt: {
type: GraphQLDate,
resolve: data => data.created_at,
},
},
});
export default ProposalStatusType;
| nambawan/g-old | src/data/types/ProposalStatusType.js | JavaScript | mit | 1,152 |
// Generated by CoffeeScript 1.12.6
/*
* Default matchers set
*/
(function() {
'use strict';
var dotted, getActual, getAsyncActual, report, unordered;
dotted = require('../common/dotted');
getActual = require('./get_actual');
getAsyncActual = require('./get_actual');
report = require('../common/object/report').create;
unordered = require('../common/unordered');
module.exports = {
"default": function(spec, specSet) {
var _;
return _ = {
actual: getActual(spec, specSet),
expected: spec.expected
};
},
anyOrder: function(spec, specSet) {
var _, actual;
actual = getActual(spec, specSet);
return _ = {
actual: unordered.compare(actual, spec.expected),
expected: unordered.clean
};
},
async: function(spec, specSet) {
var _;
return _ = {
actual: getAsyncActual(spec, specSet),
expected: spec.expected
};
},
contains: function(spec, specSet) {
var _, actual, expected;
actual = getActual(spec, specSet);
actual = report(actual);
expected = report(spec.expected);
return _ = {
actual: unordered.compare(actual, expected).extra,
expected: []
};
},
error: function(spec, specSet) {
var _, actual, e;
try {
actual = getActual(spec, specSet);
} catch (error) {
e = error;
actual = e.message;
}
return _ = {
actual: actual,
expected: spec.expected
};
},
plain: function(spec, specSet) {
var _;
return _ = {
actual: spec.input,
expected: spec.expected
};
},
property: function(spec, specSet) {
var _, actual, key, ref, value;
getActual(spec, specSet);
actual = {};
ref = spec.expected;
for (key in ref) {
value = ref[key];
actual[key] = dotted.parse(specSet.that, key);
}
return _ = {
actual: actual,
expected: spec.expected
};
}
};
}).call(this);
| ddry/ddry | lib/matchers/index.js | JavaScript | mit | 2,075 |
/*
Source: https://github.com/ReactiveSets/toubkal
The MIT License (MIT)
Copyright (c) 2013-2016, Reactive Sets
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
'use strict';
var toString = Object.prototype.toString;
/* -----------------------------------------------------------------------------------------
equals( a, b [, enforce_properties_order, cyclic] )
Returns true if a and b are deeply equal, false otherwise.
Parameters:
- a (Any type): value to compare to b
- b (Any type): value compared to a
Optional Parameters:
- enforce_properties_order (Boolean): true to check if Object properties are provided
in the same order between a and b
- cyclic (Boolean): true to check for cycles in cyclic objects
Implementation:
'a' is considered equal to 'b' if all scalar values in a and b are strictly equal as
compared with operator '===' except for these two special cases:
- 0 === -0 but are not equal.
- NaN is not === to itself but is equal.
RegExp objects are considered equal if they have the same lastIndex, i.e. both regular
expressions have matched the same number of times.
Functions must be identical, so that they have the same closure context.
"undefined" is a valid value, including in Objects
106 automated tests.
Provide options for slower, less-common use cases:
- Unless enforce_properties_order is true, if 'a' and 'b' are non-Array Objects, the
order of occurence of their attributes is considered irrelevant:
{ a: 1, b: 2 } is considered equal to { b: 2, a: 1 }
- Unless cyclic is true, Cyclic objects will throw:
RangeError: Maximum call stack size exceeded
*/
export default function equals(a, b, enforce_properties_order, cyclic) {
return a === b // strick equality should be enough unless zero
&& a !== 0 // because 0 === -0, requires test by _equals()
|| _equals(a, b) // handles not strictly equal or zero values
;
function _equals(a, b) {
// a and b have already failed test for strict equality or are zero
var s, l, p, x, y;
// They should have the same toString() signature
if (( s = toString.call(a) ) !== toString.call(b)) return false;
switch (s) {
default: // Boolean, Date, String
return a.valueOf() === b.valueOf();
case '[object Number]':
// Converts Number instances into primitive values
// This is required also for NaN test bellow
a = +a;
b = +b;
return a ? // a is Non-zero and Non-NaN
a === b
: // a is 0, -0 or NaN
a === a ? // a is 0 or -O
1 / a === 1 / b // 1/0 !== 1/-0 because Infinity !== -Infinity
: b !== b // NaN, the only Number not equal to itself!
;
// [object Number]
case '[object RegExp]':
return a.source == b.source
&& a.global == b.global
&& a.ignoreCase == b.ignoreCase
&& a.multiline == b.multiline
&& a.lastIndex == b.lastIndex
;
// [object RegExp]
case '[object Function]':
return false; // functions should be strictly equal because of closure context
// [object Function]
case '[object Array]':
if (cyclic && ( x = reference_equals(a, b) ) !== null) return x; // intentionally duplicated bellow for [object Object]
if (( l = a.length ) != b.length) return false;
// Both have as many elements
while (l--) {
if (( x = a[l] ) === ( y = b[l] ) && x !== 0 || _equals(x, y)) continue;
return false;
}
return true;
// [object Array]
case '[object Object]':
if (cyclic && ( x = reference_equals(a, b) ) !== null) return x; // intentionally duplicated from above for [object Array]
l = 0; // counter of own properties
if (enforce_properties_order) {
var properties = [];
for (p in a) {
if (a.hasOwnProperty(p)) {
properties.push(p);
if (( x = a[p] ) === ( y = b[p] ) && x !== 0 || _equals(x, y)) continue;
return false;
}
}
// Check if 'b' has as the same properties as 'a' in the same order
for (p in b)
if (b.hasOwnProperty(p) && properties[l++] != p)
return false;
} else {
for (p in a) {
if (a.hasOwnProperty(p)) {
++l;
if (( x = a[p] ) === ( y = b[p] ) && x !== 0 || _equals(x, y)) continue;
return false;
}
}
// Check if 'b' has as not more own properties than 'a'
for (p in b)
if (b.hasOwnProperty(p) && --l < 0)
return false;
}
return true;
// [object Object]
} // switch toString.call( a )
} // _equals()
/* -----------------------------------------------------------------------------------------
reference_equals( a, b )
Helper function to compare object references on cyclic objects or arrays.
Returns:
- null if a or b is not part of a cycle, adding them to object_references array
- true: same cycle found for a and b
- false: different cycle found for a and b
On the first call of a specific invocation of equal(), replaces self with inner function
holding object_references array object in closure context.
This allows to create a context only if and when an invocation of equal() compares
objects or arrays.
*/
function reference_equals(a, b) {
var object_references = [];
return ( reference_equals = _reference_equals )(a, b);
function _reference_equals(a, b) {
var l = object_references.length;
while (l--)
if (object_references[l--] === b)
return object_references[l] === a;
object_references.push(a, b);
return null;
} // _reference_equals()
} // reference_equals()
} // equals() | Vrturo/FrontEndLabz | miniProjects/imageGallery/node_modules/cloudinary-react/src/Util/equals.js | JavaScript | mit | 6,955 |
/**
* Cesium - https://github.com/AnalyticalGraphicsInc/cesium
*
* Copyright 2011-2017 Cesium Contributors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Columbus View (Pat. Pend.)
*
* Portions licensed separately.
* See https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md for full licensing details.
*/
(function () {
/*global define*/
define('Core/defined',[],function() {
'use strict';
/**
* @exports defined
*
* @param {Object} value The object.
* @returns {Boolean} Returns true if the object is defined, returns false otherwise.
*
* @example
* if (Cesium.defined(positions)) {
* doSomething();
* } else {
* doSomethingElse();
* }
*/
function defined(value) {
return value !== undefined && value !== null;
}
return defined;
});
/*global define*/
define('Core/DeveloperError',[
'./defined'
], function(
defined) {
'use strict';
/**
* Constructs an exception object that is thrown due to a developer error, e.g., invalid argument,
* argument out of range, etc. This exception should only be thrown during development;
* it usually indicates a bug in the calling code. This exception should never be
* caught; instead the calling code should strive not to generate it.
* <br /><br />
* On the other hand, a {@link RuntimeError} indicates an exception that may
* be thrown at runtime, e.g., out of memory, that the calling code should be prepared
* to catch.
*
* @alias DeveloperError
* @constructor
* @extends Error
*
* @param {String} [message] The error message for this exception.
*
* @see RuntimeError
*/
function DeveloperError(message) {
/**
* 'DeveloperError' indicating that this exception was thrown due to a developer error.
* @type {String}
* @readonly
*/
this.name = 'DeveloperError';
/**
* The explanation for why this exception was thrown.
* @type {String}
* @readonly
*/
this.message = message;
//Browsers such as IE don't have a stack property until you actually throw the error.
var stack;
try {
throw new Error();
} catch (e) {
stack = e.stack;
}
/**
* The stack trace of this exception, if available.
* @type {String}
* @readonly
*/
this.stack = stack;
}
if (defined(Object.create)) {
DeveloperError.prototype = Object.create(Error.prototype);
DeveloperError.prototype.constructor = DeveloperError;
}
DeveloperError.prototype.toString = function() {
var str = this.name + ': ' + this.message;
if (defined(this.stack)) {
str += '\n' + this.stack.toString();
}
return str;
};
/**
* @private
*/
DeveloperError.throwInstantiationError = function() {
throw new DeveloperError('This function defines an interface and should not be called directly.');
};
return DeveloperError;
});
/*global define*/
define('Core/Check',[
'./defined',
'./DeveloperError'
], function(
defined,
DeveloperError) {
'use strict';
/**
* Contains functions for checking that supplied arguments are of a specified type
* or meet specified conditions
* @private
*/
var Check = {};
/**
* Contains type checking functions, all using the typeof operator
*/
Check.typeOf = {};
function getUndefinedErrorMessage(name) {
return name + ' is required, actual value was undefined';
}
function getFailedTypeErrorMessage(actual, expected, name) {
return 'Expected ' + name + ' to be typeof ' + expected + ', actual typeof was ' + actual;
}
/**
* Throws if test is not defined
*
* @param {String} name The name of the variable being tested
* @param {*} test The value that is to be checked
* @exception {DeveloperError} test must be defined
*/
Check.defined = function (name, test) {
if (!defined(test)) {
throw new DeveloperError(getUndefinedErrorMessage(name));
}
};
/**
* Throws if test is not typeof 'function'
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @exception {DeveloperError} test must be typeof 'function'
*/
Check.typeOf.func = function (name, test) {
if (typeof test !== 'function') {
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'function', name));
}
};
/**
* Throws if test is not typeof 'string'
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @exception {DeveloperError} test must be typeof 'string'
*/
Check.typeOf.string = function (name, test) {
if (typeof test !== 'string') {
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'string', name));
}
};
/**
* Throws if test is not typeof 'number'
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @exception {DeveloperError} test must be typeof 'number'
*/
Check.typeOf.number = function (name, test) {
if (typeof test !== 'number') {
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'number', name));
}
};
/**
* Throws if test is not typeof 'number' and less than limit
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @param {Number} limit The limit value to compare against
* @exception {DeveloperError} test must be typeof 'number' and less than limit
*/
Check.typeOf.number.lessThan = function (name, test, limit) {
Check.typeOf.number(name, test);
if (test >= limit) {
throw new DeveloperError('Expected ' + name + ' to be less than ' + limit + ', actual value was ' + test);
}
};
/**
* Throws if test is not typeof 'number' and less than or equal to limit
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @param {Number} limit The limit value to compare against
* @exception {DeveloperError} test must be typeof 'number' and less than or equal to limit
*/
Check.typeOf.number.lessThanOrEquals = function (name, test, limit) {
Check.typeOf.number(name, test);
if (test > limit) {
throw new DeveloperError('Expected ' + name + ' to be less than or equal to ' + limit + ', actual value was ' + test);
}
};
/**
* Throws if test is not typeof 'number' and greater than limit
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @param {Number} limit The limit value to compare against
* @exception {DeveloperError} test must be typeof 'number' and greater than limit
*/
Check.typeOf.number.greaterThan = function (name, test, limit) {
Check.typeOf.number(name, test);
if (test <= limit) {
throw new DeveloperError('Expected ' + name + ' to be greater than ' + limit + ', actual value was ' + test);
}
};
/**
* Throws if test is not typeof 'number' and greater than or equal to limit
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @param {Number} limit The limit value to compare against
* @exception {DeveloperError} test must be typeof 'number' and greater than or equal to limit
*/
Check.typeOf.number.greaterThanOrEquals = function (name, test, limit) {
Check.typeOf.number(name, test);
if (test < limit) {
throw new DeveloperError('Expected ' + name + ' to be greater than or equal to' + limit + ', actual value was ' + test);
}
};
/**
* Throws if test is not typeof 'object'
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @exception {DeveloperError} test must be typeof 'object'
*/
Check.typeOf.object = function (name, test) {
if (typeof test !== 'object') {
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'object', name));
}
};
/**
* Throws if test is not typeof 'boolean'
*
* @param {String} name The name of the variable being tested
* @param {*} test The value to test
* @exception {DeveloperError} test must be typeof 'boolean'
*/
Check.typeOf.bool = function (name, test) {
if (typeof test !== 'boolean') {
throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'boolean', name));
}
};
return Check;
});
/*global define*/
define('Core/freezeObject',[
'./defined'
], function(
defined) {
'use strict';
/**
* Freezes an object, using Object.freeze if available, otherwise returns
* the object unchanged. This function should be used in setup code to prevent
* errors from completely halting JavaScript execution in legacy browsers.
*
* @private
*
* @exports freezeObject
*/
var freezeObject = Object.freeze;
if (!defined(freezeObject)) {
freezeObject = function(o) {
return o;
};
}
return freezeObject;
});
/*global define*/
define('Core/defaultValue',[
'./freezeObject'
], function(
freezeObject) {
'use strict';
/**
* Returns the first parameter if not undefined, otherwise the second parameter.
* Useful for setting a default value for a parameter.
*
* @exports defaultValue
*
* @param {*} a
* @param {*} b
* @returns {*} Returns the first parameter if not undefined, otherwise the second parameter.
*
* @example
* param = Cesium.defaultValue(param, 'default');
*/
function defaultValue(a, b) {
if (a !== undefined) {
return a;
}
return b;
}
/**
* A frozen empty object that can be used as the default value for options passed as
* an object literal.
*/
defaultValue.EMPTY_OBJECT = freezeObject({});
return defaultValue;
});
/*
I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
so it's better encapsulated. Now you can have multiple random number generators
and they won't stomp all over eachother's state.
If you want to use this as a substitute for Math.random(), use the random()
method like so:
var m = new MersenneTwister();
var randomNumber = m.random();
You can also call the other genrand_{foo}() methods on the instance.
If you want to use a specific seed in order to get a repeatable random
sequence, pass an integer into the constructor:
var m = new MersenneTwister(123);
and that will always produce the same random sequence.
Sean McCullough (banksean@gmail.com)
*/
/*
A C-program for MT19937, with initialization improved 2002/1/26.
Coded by Takuji Nishimura and Makoto Matsumoto.
Before using, initialize the state by using init_genrand(seed)
or init_by_array(init_key, key_length).
*/
/**
@license
mersenne-twister.js - https://gist.github.com/banksean/300494
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of its contributors may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
Any feedback is very welcome.
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
*/
define('ThirdParty/mersenne-twister',[],function() {
var MersenneTwister = function(seed) {
if (seed == undefined) {
seed = new Date().getTime();
}
/* Period parameters */
this.N = 624;
this.M = 397;
this.MATRIX_A = 0x9908b0df; /* constant vector a */
this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
this.mt = new Array(this.N); /* the array for the state vector */
this.mti=this.N+1; /* mti==N+1 means mt[N] is not initialized */
this.init_genrand(seed);
}
/* initializes mt[N] with a seed */
MersenneTwister.prototype.init_genrand = function(s) {
this.mt[0] = s >>> 0;
for (this.mti=1; this.mti<this.N; this.mti++) {
var s = this.mt[this.mti-1] ^ (this.mt[this.mti-1] >>> 30);
this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
+ this.mti;
/* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
/* In the previous versions, MSBs of the seed affect */
/* only MSBs of the array mt[]. */
/* 2002/01/09 modified by Makoto Matsumoto */
this.mt[this.mti] >>>= 0;
/* for >32 bit machines */
}
}
/* initialize by an array with array-length */
/* init_key is the array for initializing keys */
/* key_length is its length */
/* slight change for C++, 2004/2/26 */
//MersenneTwister.prototype.init_by_array = function(init_key, key_length) {
// var i, j, k;
// this.init_genrand(19650218);
// i=1; j=0;
// k = (this.N>key_length ? this.N : key_length);
// for (; k; k--) {
// var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30)
// this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))
// + init_key[j] + j; /* non linear */
// this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
// i++; j++;
// if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }
// if (j>=key_length) j=0;
// }
// for (k=this.N-1; k; k--) {
// var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30);
// this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))
// - i; /* non linear */
// this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
// i++;
// if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }
// }
//
// this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
//}
/* generates a random number on [0,0xffffffff]-interval */
MersenneTwister.prototype.genrand_int32 = function() {
var y;
var mag01 = new Array(0x0, this.MATRIX_A);
/* mag01[x] = x * MATRIX_A for x=0,1 */
if (this.mti >= this.N) { /* generate N words at one time */
var kk;
if (this.mti == this.N+1) /* if init_genrand() has not been called, */
this.init_genrand(5489); /* a default initial seed is used */
for (kk=0;kk<this.N-this.M;kk++) {
y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);
this.mt[kk] = this.mt[kk+this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
}
for (;kk<this.N-1;kk++) {
y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);
this.mt[kk] = this.mt[kk+(this.M-this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
}
y = (this.mt[this.N-1]&this.UPPER_MASK)|(this.mt[0]&this.LOWER_MASK);
this.mt[this.N-1] = this.mt[this.M-1] ^ (y >>> 1) ^ mag01[y & 0x1];
this.mti = 0;
}
y = this.mt[this.mti++];
/* Tempering */
y ^= (y >>> 11);
y ^= (y << 7) & 0x9d2c5680;
y ^= (y << 15) & 0xefc60000;
y ^= (y >>> 18);
return y >>> 0;
}
/* generates a random number on [0,0x7fffffff]-interval */
//MersenneTwister.prototype.genrand_int31 = function() {
// return (this.genrand_int32()>>>1);
//}
/* generates a random number on [0,1]-real-interval */
//MersenneTwister.prototype.genrand_real1 = function() {
// return this.genrand_int32()*(1.0/4294967295.0);
// /* divided by 2^32-1 */
//}
/* generates a random number on [0,1)-real-interval */
MersenneTwister.prototype.random = function() {
return this.genrand_int32()*(1.0/4294967296.0);
/* divided by 2^32 */
}
/* generates a random number on (0,1)-real-interval */
//MersenneTwister.prototype.genrand_real3 = function() {
// return (this.genrand_int32() + 0.5)*(1.0/4294967296.0);
// /* divided by 2^32 */
//}
/* generates a random number on [0,1) with 53-bit resolution*/
//MersenneTwister.prototype.genrand_res53 = function() {
// var a=this.genrand_int32()>>>5, b=this.genrand_int32()>>>6;
// return(a*67108864.0+b)*(1.0/9007199254740992.0);
//}
/* These real versions are due to Isaku Wada, 2002/01/09 added */
return MersenneTwister;
});
/*global define*/
define('Core/Math',[
'../ThirdParty/mersenne-twister',
'./defaultValue',
'./defined',
'./DeveloperError'
], function(
MersenneTwister,
defaultValue,
defined,
DeveloperError) {
'use strict';
/**
* Math functions.
*
* @exports CesiumMath
*/
var CesiumMath = {};
/**
* 0.1
* @type {Number}
* @constant
*/
CesiumMath.EPSILON1 = 0.1;
/**
* 0.01
* @type {Number}
* @constant
*/
CesiumMath.EPSILON2 = 0.01;
/**
* 0.001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON3 = 0.001;
/**
* 0.0001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON4 = 0.0001;
/**
* 0.00001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON5 = 0.00001;
/**
* 0.000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON6 = 0.000001;
/**
* 0.0000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON7 = 0.0000001;
/**
* 0.00000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON8 = 0.00000001;
/**
* 0.000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON9 = 0.000000001;
/**
* 0.0000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON10 = 0.0000000001;
/**
* 0.00000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON11 = 0.00000000001;
/**
* 0.000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON12 = 0.000000000001;
/**
* 0.0000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON13 = 0.0000000000001;
/**
* 0.00000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON14 = 0.00000000000001;
/**
* 0.000000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON15 = 0.000000000000001;
/**
* 0.0000000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON16 = 0.0000000000000001;
/**
* 0.00000000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON17 = 0.00000000000000001;
/**
* 0.000000000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON18 = 0.000000000000000001;
/**
* 0.0000000000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON19 = 0.0000000000000000001;
/**
* 0.00000000000000000001
* @type {Number}
* @constant
*/
CesiumMath.EPSILON20 = 0.00000000000000000001;
/**
* 3.986004418e14
* @type {Number}
* @constant
*/
CesiumMath.GRAVITATIONALPARAMETER = 3.986004418e14;
/**
* Radius of the sun in meters: 6.955e8
* @type {Number}
* @constant
*/
CesiumMath.SOLAR_RADIUS = 6.955e8;
/**
* The mean radius of the moon, according to the "Report of the IAU/IAG Working Group on
* Cartographic Coordinates and Rotational Elements of the Planets and satellites: 2000",
* Celestial Mechanics 82: 83-110, 2002.
* @type {Number}
* @constant
*/
CesiumMath.LUNAR_RADIUS = 1737400.0;
/**
* 64 * 1024
* @type {Number}
* @constant
*/
CesiumMath.SIXTY_FOUR_KILOBYTES = 64 * 1024;
/**
* Returns the sign of the value; 1 if the value is positive, -1 if the value is
* negative, or 0 if the value is 0.
*
* @param {Number} value The value to return the sign of.
* @returns {Number} The sign of value.
*/
CesiumMath.sign = function(value) {
if (value > 0) {
return 1;
}
if (value < 0) {
return -1;
}
return 0;
};
/**
* Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.
* This is similar to {@link CesiumMath#sign} except that returns 1.0 instead of
* 0.0 when the input value is 0.0.
* @param {Number} value The value to return the sign of.
* @returns {Number} The sign of value.
*/
CesiumMath.signNotZero = function(value) {
return value < 0.0 ? -1.0 : 1.0;
};
/**
* Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMax]
* @param {Number} value The scalar value in the range [-1.0, 1.0]
* @param {Number} [rangeMax=255] The maximum value in the mapped range, 255 by default.
* @returns {Number} A SNORM value, where 0 maps to -1.0 and rangeMax maps to 1.0.
*
* @see CesiumMath.fromSNorm
*/
CesiumMath.toSNorm = function(value, rangeMax) {
rangeMax = defaultValue(rangeMax, 255);
return Math.round((CesiumMath.clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMax);
};
/**
* Converts a SNORM value in the range [0, rangeMax] to a scalar in the range [-1.0, 1.0].
* @param {Number} value SNORM value in the range [0, 255]
* @param {Number} [rangeMax=255] The maximum value in the SNORM range, 255 by default.
* @returns {Number} Scalar in the range [-1.0, 1.0].
*
* @see CesiumMath.toSNorm
*/
CesiumMath.fromSNorm = function(value, rangeMax) {
rangeMax = defaultValue(rangeMax, 255);
return CesiumMath.clamp(value, 0.0, rangeMax) / rangeMax * 2.0 - 1.0;
};
/**
* Returns the hyperbolic sine of a number.
* The hyperbolic sine of <em>value</em> is defined to be
* (<em>e<sup>x</sup> - e<sup>-x</sup></em>)/2.0
* where <i>e</i> is Euler's number, approximately 2.71828183.
*
* <p>Special cases:
* <ul>
* <li>If the argument is NaN, then the result is NaN.</li>
*
* <li>If the argument is infinite, then the result is an infinity
* with the same sign as the argument.</li>
*
* <li>If the argument is zero, then the result is a zero with the
* same sign as the argument.</li>
* </ul>
*</p>
*
* @param {Number} value The number whose hyperbolic sine is to be returned.
* @returns {Number} The hyperbolic sine of <code>value</code>.
*/
CesiumMath.sinh = function(value) {
var part1 = Math.pow(Math.E, value);
var part2 = Math.pow(Math.E, -1.0 * value);
return (part1 - part2) * 0.5;
};
/**
* Returns the hyperbolic cosine of a number.
* The hyperbolic cosine of <strong>value</strong> is defined to be
* (<em>e<sup>x</sup> + e<sup>-x</sup></em>)/2.0
* where <i>e</i> is Euler's number, approximately 2.71828183.
*
* <p>Special cases:
* <ul>
* <li>If the argument is NaN, then the result is NaN.</li>
*
* <li>If the argument is infinite, then the result is positive infinity.</li>
*
* <li>If the argument is zero, then the result is 1.0.</li>
* </ul>
*</p>
*
* @param {Number} value The number whose hyperbolic cosine is to be returned.
* @returns {Number} The hyperbolic cosine of <code>value</code>.
*/
CesiumMath.cosh = function(value) {
var part1 = Math.pow(Math.E, value);
var part2 = Math.pow(Math.E, -1.0 * value);
return (part1 + part2) * 0.5;
};
/**
* Computes the linear interpolation of two values.
*
* @param {Number} p The start value to interpolate.
* @param {Number} q The end value to interpolate.
* @param {Number} time The time of interpolation generally in the range <code>[0.0, 1.0]</code>.
* @returns {Number} The linearly interpolated value.
*
* @example
* var n = Cesium.Math.lerp(0.0, 2.0, 0.5); // returns 1.0
*/
CesiumMath.lerp = function(p, q, time) {
return ((1.0 - time) * p) + (time * q);
};
/**
* pi
*
* @type {Number}
* @constant
*/
CesiumMath.PI = Math.PI;
/**
* 1/pi
*
* @type {Number}
* @constant
*/
CesiumMath.ONE_OVER_PI = 1.0 / Math.PI;
/**
* pi/2
*
* @type {Number}
* @constant
*/
CesiumMath.PI_OVER_TWO = Math.PI * 0.5;
/**
* pi/3
*
* @type {Number}
* @constant
*/
CesiumMath.PI_OVER_THREE = Math.PI / 3.0;
/**
* pi/4
*
* @type {Number}
* @constant
*/
CesiumMath.PI_OVER_FOUR = Math.PI / 4.0;
/**
* pi/6
*
* @type {Number}
* @constant
*/
CesiumMath.PI_OVER_SIX = Math.PI / 6.0;
/**
* 3pi/2
*
* @type {Number}
* @constant
*/
CesiumMath.THREE_PI_OVER_TWO = (3.0 * Math.PI) * 0.5;
/**
* 2pi
*
* @type {Number}
* @constant
*/
CesiumMath.TWO_PI = 2.0 * Math.PI;
/**
* 1/2pi
*
* @type {Number}
* @constant
*/
CesiumMath.ONE_OVER_TWO_PI = 1.0 / (2.0 * Math.PI);
/**
* The number of radians in a degree.
*
* @type {Number}
* @constant
* @default Math.PI / 180.0
*/
CesiumMath.RADIANS_PER_DEGREE = Math.PI / 180.0;
/**
* The number of degrees in a radian.
*
* @type {Number}
* @constant
* @default 180.0 / Math.PI
*/
CesiumMath.DEGREES_PER_RADIAN = 180.0 / Math.PI;
/**
* The number of radians in an arc second.
*
* @type {Number}
* @constant
* @default {@link CesiumMath.RADIANS_PER_DEGREE} / 3600.0
*/
CesiumMath.RADIANS_PER_ARCSECOND = CesiumMath.RADIANS_PER_DEGREE / 3600.0;
/**
* Converts degrees to radians.
* @param {Number} degrees The angle to convert in degrees.
* @returns {Number} The corresponding angle in radians.
*/
CesiumMath.toRadians = function(degrees) {
if (!defined(degrees)) {
throw new DeveloperError('degrees is required.');
}
return degrees * CesiumMath.RADIANS_PER_DEGREE;
};
/**
* Converts radians to degrees.
* @param {Number} radians The angle to convert in radians.
* @returns {Number} The corresponding angle in degrees.
*/
CesiumMath.toDegrees = function(radians) {
if (!defined(radians)) {
throw new DeveloperError('radians is required.');
}
return radians * CesiumMath.DEGREES_PER_RADIAN;
};
/**
* Converts a longitude value, in radians, to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
*
* @param {Number} angle The longitude value, in radians, to convert to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
* @returns {Number} The equivalent longitude value in the range [<code>-Math.PI</code>, <code>Math.PI</code>).
*
* @example
* // Convert 270 degrees to -90 degrees longitude
* var longitude = Cesium.Math.convertLongitudeRange(Cesium.Math.toRadians(270.0));
*/
CesiumMath.convertLongitudeRange = function(angle) {
if (!defined(angle)) {
throw new DeveloperError('angle is required.');
}
var twoPi = CesiumMath.TWO_PI;
var simplified = angle - Math.floor(angle / twoPi) * twoPi;
if (simplified < -Math.PI) {
return simplified + twoPi;
}
if (simplified >= Math.PI) {
return simplified - twoPi;
}
return simplified;
};
/**
* Convenience function that clamps a latitude value, in radians, to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).
* Useful for sanitizing data before use in objects requiring correct range.
*
* @param {Number} angle The latitude value, in radians, to clamp to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).
* @returns {Number} The latitude value clamped to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).
*
* @example
* // Clamp 108 degrees latitude to 90 degrees latitude
* var latitude = Cesium.Math.clampToLatitudeRange(Cesium.Math.toRadians(108.0));
*/
CesiumMath.clampToLatitudeRange = function(angle) {
if (!defined(angle)) {
throw new DeveloperError('angle is required.');
}
return CesiumMath.clamp(angle, -1*CesiumMath.PI_OVER_TWO, CesiumMath.PI_OVER_TWO);
};
/**
* Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
*
* @param {Number} angle in radians
* @returns {Number} The angle in the range [<code>-CesiumMath.PI</code>, <code>CesiumMath.PI</code>].
*/
CesiumMath.negativePiToPi = function(angle) {
if (!defined(angle)) {
throw new DeveloperError('angle is required.');
}
return CesiumMath.zeroToTwoPi(angle + CesiumMath.PI) - CesiumMath.PI;
};
/**
* Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
*
* @param {Number} angle in radians
* @returns {Number} The angle in the range [0, <code>CesiumMath.TWO_PI</code>].
*/
CesiumMath.zeroToTwoPi = function(angle) {
if (!defined(angle)) {
throw new DeveloperError('angle is required.');
}
var mod = CesiumMath.mod(angle, CesiumMath.TWO_PI);
if (Math.abs(mod) < CesiumMath.EPSILON14 && Math.abs(angle) > CesiumMath.EPSILON14) {
return CesiumMath.TWO_PI;
}
return mod;
};
/**
* The modulo operation that also works for negative dividends.
*
* @param {Number} m The dividend.
* @param {Number} n The divisor.
* @returns {Number} The remainder.
*/
CesiumMath.mod = function(m, n) {
if (!defined(m)) {
throw new DeveloperError('m is required.');
}
if (!defined(n)) {
throw new DeveloperError('n is required.');
}
return ((m % n) + n) % n;
};
/**
* Determines if two values are equal using an absolute or relative tolerance test. This is useful
* to avoid problems due to roundoff error when comparing floating-point values directly. The values are
* first compared using an absolute tolerance test. If that fails, a relative tolerance test is performed.
* Use this test if you are unsure of the magnitudes of left and right.
*
* @param {Number} left The first value to compare.
* @param {Number} right The other value to compare.
* @param {Number} relativeEpsilon The maximum inclusive delta between <code>left</code> and <code>right</code> for the relative tolerance test.
* @param {Number} [absoluteEpsilon=relativeEpsilon] The maximum inclusive delta between <code>left</code> and <code>right</code> for the absolute tolerance test.
* @returns {Boolean} <code>true</code> if the values are equal within the epsilon; otherwise, <code>false</code>.
*
* @example
* var a = Cesium.Math.equalsEpsilon(0.0, 0.01, Cesium.Math.EPSILON2); // true
* var b = Cesium.Math.equalsEpsilon(0.0, 0.1, Cesium.Math.EPSILON2); // false
* var c = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON7); // true
* var d = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON9); // false
*/
CesiumMath.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
if (!defined(left)) {
throw new DeveloperError('left is required.');
}
if (!defined(right)) {
throw new DeveloperError('right is required.');
}
if (!defined(relativeEpsilon)) {
throw new DeveloperError('relativeEpsilon is required.');
}
absoluteEpsilon = defaultValue(absoluteEpsilon, relativeEpsilon);
var absDiff = Math.abs(left - right);
return absDiff <= absoluteEpsilon || absDiff <= relativeEpsilon * Math.max(Math.abs(left), Math.abs(right));
};
var factorials = [1];
/**
* Computes the factorial of the provided number.
*
* @param {Number} n The number whose factorial is to be computed.
* @returns {Number} The factorial of the provided number or undefined if the number is less than 0.
*
* @exception {DeveloperError} A number greater than or equal to 0 is required.
*
*
* @example
* //Compute 7!, which is equal to 5040
* var computedFactorial = Cesium.Math.factorial(7);
*
* @see {@link http://en.wikipedia.org/wiki/Factorial|Factorial on Wikipedia}
*/
CesiumMath.factorial = function(n) {
if (typeof n !== 'number' || n < 0) {
throw new DeveloperError('A number greater than or equal to 0 is required.');
}
var length = factorials.length;
if (n >= length) {
var sum = factorials[length - 1];
for (var i = length; i <= n; i++) {
factorials.push(sum * i);
}
}
return factorials[n];
};
/**
* Increments a number with a wrapping to a minimum value if the number exceeds the maximum value.
*
* @param {Number} [n] The number to be incremented.
* @param {Number} [maximumValue] The maximum incremented value before rolling over to the minimum value.
* @param {Number} [minimumValue=0.0] The number reset to after the maximum value has been exceeded.
* @returns {Number} The incremented number.
*
* @exception {DeveloperError} Maximum value must be greater than minimum value.
*
* @example
* var n = Cesium.Math.incrementWrap(5, 10, 0); // returns 6
* var n = Cesium.Math.incrementWrap(10, 10, 0); // returns 0
*/
CesiumMath.incrementWrap = function(n, maximumValue, minimumValue) {
minimumValue = defaultValue(minimumValue, 0.0);
if (!defined(n)) {
throw new DeveloperError('n is required.');
}
if (maximumValue <= minimumValue) {
throw new DeveloperError('maximumValue must be greater than minimumValue.');
}
++n;
if (n > maximumValue) {
n = minimumValue;
}
return n;
};
/**
* Determines if a positive integer is a power of two.
*
* @param {Number} n The positive integer to test.
* @returns {Boolean} <code>true</code> if the number if a power of two; otherwise, <code>false</code>.
*
* @exception {DeveloperError} A number greater than or equal to 0 is required.
*
* @example
* var t = Cesium.Math.isPowerOfTwo(16); // true
* var f = Cesium.Math.isPowerOfTwo(20); // false
*/
CesiumMath.isPowerOfTwo = function(n) {
if (typeof n !== 'number' || n < 0) {
throw new DeveloperError('A number greater than or equal to 0 is required.');
}
return (n !== 0) && ((n & (n - 1)) === 0);
};
/**
* Computes the next power-of-two integer greater than or equal to the provided positive integer.
*
* @param {Number} n The positive integer to test.
* @returns {Number} The next power-of-two integer.
*
* @exception {DeveloperError} A number greater than or equal to 0 is required.
*
* @example
* var n = Cesium.Math.nextPowerOfTwo(29); // 32
* var m = Cesium.Math.nextPowerOfTwo(32); // 32
*/
CesiumMath.nextPowerOfTwo = function(n) {
if (typeof n !== 'number' || n < 0) {
throw new DeveloperError('A number greater than or equal to 0 is required.');
}
// From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
--n;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
++n;
return n;
};
/**
* Constraint a value to lie between two values.
*
* @param {Number} value The value to constrain.
* @param {Number} min The minimum value.
* @param {Number} max The maximum value.
* @returns {Number} The value clamped so that min <= value <= max.
*/
CesiumMath.clamp = function(value, min, max) {
if (!defined(value)) {
throw new DeveloperError('value is required');
}
if (!defined(min)) {
throw new DeveloperError('min is required.');
}
if (!defined(max)) {
throw new DeveloperError('max is required.');
}
return value < min ? min : value > max ? max : value;
};
var randomNumberGenerator = new MersenneTwister();
/**
* Sets the seed used by the random number generator
* in {@link CesiumMath#nextRandomNumber}.
*
* @param {Number} seed An integer used as the seed.
*/
CesiumMath.setRandomNumberSeed = function(seed) {
if (!defined(seed)) {
throw new DeveloperError('seed is required.');
}
randomNumberGenerator = new MersenneTwister(seed);
};
/**
* Generates a random number in the range of [0.0, 1.0)
* using a Mersenne twister.
*
* @returns {Number} A random number in the range of [0.0, 1.0).
*
* @see CesiumMath.setRandomNumberSeed
* @see {@link http://en.wikipedia.org/wiki/Mersenne_twister|Mersenne twister on Wikipedia}
*/
CesiumMath.nextRandomNumber = function() {
return randomNumberGenerator.random();
};
/**
* Computes <code>Math.acos(value)</acode>, but first clamps <code>value</code> to the range [-1.0, 1.0]
* so that the function will never return NaN.
*
* @param {Number} value The value for which to compute acos.
* @returns {Number} The acos of the value if the value is in the range [-1.0, 1.0], or the acos of -1.0 or 1.0,
* whichever is closer, if the value is outside the range.
*/
CesiumMath.acosClamped = function(value) {
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
return Math.acos(CesiumMath.clamp(value, -1.0, 1.0));
};
/**
* Computes <code>Math.asin(value)</acode>, but first clamps <code>value</code> to the range [-1.0, 1.0]
* so that the function will never return NaN.
*
* @param {Number} value The value for which to compute asin.
* @returns {Number} The asin of the value if the value is in the range [-1.0, 1.0], or the asin of -1.0 or 1.0,
* whichever is closer, if the value is outside the range.
*/
CesiumMath.asinClamped = function(value) {
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
return Math.asin(CesiumMath.clamp(value, -1.0, 1.0));
};
/**
* Finds the chord length between two points given the circle's radius and the angle between the points.
*
* @param {Number} angle The angle between the two points.
* @param {Number} radius The radius of the circle.
* @returns {Number} The chord length.
*/
CesiumMath.chordLength = function(angle, radius) {
if (!defined(angle)) {
throw new DeveloperError('angle is required.');
}
if (!defined(radius)) {
throw new DeveloperError('radius is required.');
}
return 2.0 * radius * Math.sin(angle * 0.5);
};
/**
* Finds the logarithm of a number to a base.
*
* @param {Number} number The number.
* @param {Number} base The base.
* @returns {Number} The result.
*/
CesiumMath.logBase = function(number, base) {
if (!defined(number)) {
throw new DeveloperError('number is required.');
}
if (!defined(base)) {
throw new DeveloperError('base is required.');
}
return Math.log(number) / Math.log(base);
};
/**
* @private
*/
CesiumMath.fog = function(distanceToCamera, density) {
var scalar = distanceToCamera * density;
return 1.0 - Math.exp(-(scalar * scalar));
};
return CesiumMath;
});
/*global define*/
define('Core/Cartesian3',[
'./Check',
'./defaultValue',
'./defined',
'./DeveloperError',
'./freezeObject',
'./Math'
], function(
Check,
defaultValue,
defined,
DeveloperError,
freezeObject,
CesiumMath) {
'use strict';
/**
* A 3D Cartesian point.
* @alias Cartesian3
* @constructor
*
* @param {Number} [x=0.0] The X component.
* @param {Number} [y=0.0] The Y component.
* @param {Number} [z=0.0] The Z component.
*
* @see Cartesian2
* @see Cartesian4
* @see Packable
*/
function Cartesian3(x, y, z) {
/**
* The X component.
* @type {Number}
* @default 0.0
*/
this.x = defaultValue(x, 0.0);
/**
* The Y component.
* @type {Number}
* @default 0.0
*/
this.y = defaultValue(y, 0.0);
/**
* The Z component.
* @type {Number}
* @default 0.0
*/
this.z = defaultValue(z, 0.0);
}
/**
* Converts the provided Spherical into Cartesian3 coordinates.
*
* @param {Spherical} spherical The Spherical to be converted to Cartesian3.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
*/
Cartesian3.fromSpherical = function(spherical, result) {
Check.typeOf.object('spherical', spherical);
if (!defined(result)) {
result = new Cartesian3();
}
var clock = spherical.clock;
var cone = spherical.cone;
var magnitude = defaultValue(spherical.magnitude, 1.0);
var radial = magnitude * Math.sin(cone);
result.x = radial * Math.cos(clock);
result.y = radial * Math.sin(clock);
result.z = magnitude * Math.cos(cone);
return result;
};
/**
* Creates a Cartesian3 instance from x, y and z coordinates.
*
* @param {Number} x The x coordinate.
* @param {Number} y The y coordinate.
* @param {Number} z The z coordinate.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
*/
Cartesian3.fromElements = function(x, y, z, result) {
if (!defined(result)) {
return new Cartesian3(x, y, z);
}
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Duplicates a Cartesian3 instance.
*
* @param {Cartesian3} cartesian The Cartesian to duplicate.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided. (Returns undefined if cartesian is undefined)
*/
Cartesian3.clone = function(cartesian, result) {
if (!defined(cartesian)) {
return undefined;
}
if (!defined(result)) {
return new Cartesian3(cartesian.x, cartesian.y, cartesian.z);
}
result.x = cartesian.x;
result.y = cartesian.y;
result.z = cartesian.z;
return result;
};
/**
* Creates a Cartesian3 instance from an existing Cartesian4. This simply takes the
* x, y, and z properties of the Cartesian4 and drops w.
* @function
*
* @param {Cartesian4} cartesian The Cartesian4 instance to create a Cartesian3 instance from.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
*/
Cartesian3.fromCartesian4 = Cartesian3.clone;
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Cartesian3.packedLength = 3;
/**
* Stores the provided instance into the provided array.
*
* @param {Cartesian3} 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
*/
Cartesian3.pack = function(value, array, startingIndex) {
Check.typeOf.object('value', value);
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value.x;
array[startingIndex++] = value.y;
array[startingIndex] = value.z;
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 {Cartesian3} [result] The object into which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
*/
Cartesian3.unpack = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Cartesian3();
}
result.x = array[startingIndex++];
result.y = array[startingIndex++];
result.z = array[startingIndex];
return result;
};
/**
* Flattens an array of Cartesian3s into an array of components.
*
* @param {Cartesian3[]} array The array of cartesians to pack.
* @param {Number[]} result The array onto which to store the result.
* @returns {Number[]} The packed array.
*/
Cartesian3.packArray = function(array, result) {
Check.defined('array', array);
var length = array.length;
if (!defined(result)) {
result = new Array(length * 3);
} else {
result.length = length * 3;
}
for (var i = 0; i < length; ++i) {
Cartesian3.pack(array[i], result, i * 3);
}
return result;
};
/**
* Unpacks an array of cartesian components into an array of Cartesian3s.
*
* @param {Number[]} array The array of components to unpack.
* @param {Cartesian3[]} result The array onto which to store the result.
* @returns {Cartesian3[]} The unpacked array.
*/
Cartesian3.unpackArray = function(array, result) {
Check.defined('array', array);
Check.typeOf.number.greaterThanOrEquals('array.length', array.length, 3);
if (array.length % 3 !== 0) {
throw new DeveloperError('array length must be a multiple of 3.');
}
var length = array.length;
if (!defined(result)) {
result = new Array(length / 3);
} else {
result.length = length / 3;
}
for (var i = 0; i < length; i += 3) {
var index = i / 3;
result[index] = Cartesian3.unpack(array, i, result[index]);
}
return result;
};
/**
* Creates a Cartesian3 from three consecutive elements in an array.
* @function
*
* @param {Number[]} array The array whose three consecutive elements correspond to the x, y, and z components, respectively.
* @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to the x component.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
*
* @example
* // Create a Cartesian3 with (1.0, 2.0, 3.0)
* var v = [1.0, 2.0, 3.0];
* var p = Cesium.Cartesian3.fromArray(v);
*
* // Create a Cartesian3 with (1.0, 2.0, 3.0) using an offset into an array
* var v2 = [0.0, 0.0, 1.0, 2.0, 3.0];
* var p2 = Cesium.Cartesian3.fromArray(v2, 2);
*/
Cartesian3.fromArray = Cartesian3.unpack;
/**
* Computes the value of the maximum component for the supplied Cartesian.
*
* @param {Cartesian3} cartesian The cartesian to use.
* @returns {Number} The value of the maximum component.
*/
Cartesian3.maximumComponent = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return Math.max(cartesian.x, cartesian.y, cartesian.z);
};
/**
* Computes the value of the minimum component for the supplied Cartesian.
*
* @param {Cartesian3} cartesian The cartesian to use.
* @returns {Number} The value of the minimum component.
*/
Cartesian3.minimumComponent = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return Math.min(cartesian.x, cartesian.y, cartesian.z);
};
/**
* Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
*
* @param {Cartesian3} first A cartesian to compare.
* @param {Cartesian3} second A cartesian to compare.
* @param {Cartesian3} result The object into which to store the result.
* @returns {Cartesian3} A cartesian with the minimum components.
*/
Cartesian3.minimumByComponent = function(first, second, result) {
Check.typeOf.object('first', first);
Check.typeOf.object('second', second);
Check.typeOf.object('result', result);
result.x = Math.min(first.x, second.x);
result.y = Math.min(first.y, second.y);
result.z = Math.min(first.z, second.z);
return result;
};
/**
* Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
*
* @param {Cartesian3} first A cartesian to compare.
* @param {Cartesian3} second A cartesian to compare.
* @param {Cartesian3} result The object into which to store the result.
* @returns {Cartesian3} A cartesian with the maximum components.
*/
Cartesian3.maximumByComponent = function(first, second, result) {
Check.typeOf.object('first', first);
Check.typeOf.object('second', second);
Check.typeOf.object('result', result);
result.x = Math.max(first.x, second.x);
result.y = Math.max(first.y, second.y);
result.z = Math.max(first.z, second.z);
return result;
};
/**
* Computes the provided Cartesian's squared magnitude.
*
* @param {Cartesian3} cartesian The Cartesian instance whose squared magnitude is to be computed.
* @returns {Number} The squared magnitude.
*/
Cartesian3.magnitudeSquared = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return cartesian.x * cartesian.x + cartesian.y * cartesian.y + cartesian.z * cartesian.z;
};
/**
* Computes the Cartesian's magnitude (length).
*
* @param {Cartesian3} cartesian The Cartesian instance whose magnitude is to be computed.
* @returns {Number} The magnitude.
*/
Cartesian3.magnitude = function(cartesian) {
return Math.sqrt(Cartesian3.magnitudeSquared(cartesian));
};
var distanceScratch = new Cartesian3();
/**
* Computes the distance between two points.
*
* @param {Cartesian3} left The first point to compute the distance from.
* @param {Cartesian3} right The second point to compute the distance to.
* @returns {Number} The distance between two points.
*
* @example
* // Returns 1.0
* var d = Cesium.Cartesian3.distance(new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(2.0, 0.0, 0.0));
*/
Cartesian3.distance = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Cartesian3.subtract(left, right, distanceScratch);
return Cartesian3.magnitude(distanceScratch);
};
/**
* Computes the squared distance between two points. Comparing squared distances
* using this function is more efficient than comparing distances using {@link Cartesian3#distance}.
*
* @param {Cartesian3} left The first point to compute the distance from.
* @param {Cartesian3} right The second point to compute the distance to.
* @returns {Number} The distance between two points.
*
* @example
* // Returns 4.0, not 2.0
* var d = Cesium.Cartesian3.distanceSquared(new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(3.0, 0.0, 0.0));
*/
Cartesian3.distanceSquared = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Cartesian3.subtract(left, right, distanceScratch);
return Cartesian3.magnitudeSquared(distanceScratch);
};
/**
* Computes the normalized form of the supplied Cartesian.
*
* @param {Cartesian3} cartesian The Cartesian to be normalized.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.normalize = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var magnitude = Cartesian3.magnitude(cartesian);
result.x = cartesian.x / magnitude;
result.y = cartesian.y / magnitude;
result.z = cartesian.z / magnitude;
if (isNaN(result.x) || isNaN(result.y) || isNaN(result.z)) {
throw new DeveloperError('normalized result is not a number');
}
return result;
};
/**
* Computes the dot (scalar) product of two Cartesians.
*
* @param {Cartesian3} left The first Cartesian.
* @param {Cartesian3} right The second Cartesian.
* @returns {Number} The dot product.
*/
Cartesian3.dot = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
return left.x * right.x + left.y * right.y + left.z * right.z;
};
/**
* Computes the componentwise product of two Cartesians.
*
* @param {Cartesian3} left The first Cartesian.
* @param {Cartesian3} right The second Cartesian.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.multiplyComponents = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result.x = left.x * right.x;
result.y = left.y * right.y;
result.z = left.z * right.z;
return result;
};
/**
* Computes the componentwise quotient of two Cartesians.
*
* @param {Cartesian3} left The first Cartesian.
* @param {Cartesian3} right The second Cartesian.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.divideComponents = function(left, right, result) {
if (!defined(left)) {
throw new DeveloperError('left is required');
}
if (!defined(right)) {
throw new DeveloperError('right is required');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.x = left.x / right.x;
result.y = left.y / right.y;
result.z = left.z / right.z;
return result;
};
/**
* Computes the componentwise sum of two Cartesians.
*
* @param {Cartesian3} left The first Cartesian.
* @param {Cartesian3} right The second Cartesian.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.add = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result.x = left.x + right.x;
result.y = left.y + right.y;
result.z = left.z + right.z;
return result;
};
/**
* Computes the componentwise difference of two Cartesians.
*
* @param {Cartesian3} left The first Cartesian.
* @param {Cartesian3} right The second Cartesian.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.subtract = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result.x = left.x - right.x;
result.y = left.y - right.y;
result.z = left.z - right.z;
return result;
};
/**
* Multiplies the provided Cartesian componentwise by the provided scalar.
*
* @param {Cartesian3} cartesian The Cartesian to be scaled.
* @param {Number} scalar The scalar to multiply with.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.multiplyByScalar = function(cartesian, scalar, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.number('scalar', scalar);
Check.typeOf.object('result', result);
result.x = cartesian.x * scalar;
result.y = cartesian.y * scalar;
result.z = cartesian.z * scalar;
return result;
};
/**
* Divides the provided Cartesian componentwise by the provided scalar.
*
* @param {Cartesian3} cartesian The Cartesian to be divided.
* @param {Number} scalar The scalar to divide by.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.divideByScalar = function(cartesian, scalar, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.number('scalar', scalar);
Check.typeOf.object('result', result);
result.x = cartesian.x / scalar;
result.y = cartesian.y / scalar;
result.z = cartesian.z / scalar;
return result;
};
/**
* Negates the provided Cartesian.
*
* @param {Cartesian3} cartesian The Cartesian to be negated.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.negate = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result.x = -cartesian.x;
result.y = -cartesian.y;
result.z = -cartesian.z;
return result;
};
/**
* Computes the absolute value of the provided Cartesian.
*
* @param {Cartesian3} cartesian The Cartesian whose absolute value is to be computed.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.abs = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result.x = Math.abs(cartesian.x);
result.y = Math.abs(cartesian.y);
result.z = Math.abs(cartesian.z);
return result;
};
var lerpScratch = new Cartesian3();
/**
* Computes the linear interpolation or extrapolation at t using the provided cartesians.
*
* @param {Cartesian3} start The value corresponding to t at 0.0.
* @param {Cartesian3} end The value corresponding to t at 1.0.
* @param {Number} t The point along t at which to interpolate.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Cartesian3.lerp = function(start, end, t, result) {
Check.typeOf.object('start', start);
Check.typeOf.object('end', end);
Check.typeOf.number('t', t);
Check.typeOf.object('result', result);
Cartesian3.multiplyByScalar(end, t, lerpScratch);
result = Cartesian3.multiplyByScalar(start, 1.0 - t, result);
return Cartesian3.add(lerpScratch, result, result);
};
var angleBetweenScratch = new Cartesian3();
var angleBetweenScratch2 = new Cartesian3();
/**
* Returns the angle, in radians, between the provided Cartesians.
*
* @param {Cartesian3} left The first Cartesian.
* @param {Cartesian3} right The second Cartesian.
* @returns {Number} The angle between the Cartesians.
*/
Cartesian3.angleBetween = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Cartesian3.normalize(left, angleBetweenScratch);
Cartesian3.normalize(right, angleBetweenScratch2);
var cosine = Cartesian3.dot(angleBetweenScratch, angleBetweenScratch2);
var sine = Cartesian3.magnitude(Cartesian3.cross(angleBetweenScratch, angleBetweenScratch2, angleBetweenScratch));
return Math.atan2(sine, cosine);
};
var mostOrthogonalAxisScratch = new Cartesian3();
/**
* Returns the axis that is most orthogonal to the provided Cartesian.
*
* @param {Cartesian3} cartesian The Cartesian on which to find the most orthogonal axis.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The most orthogonal axis.
*/
Cartesian3.mostOrthogonalAxis = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var f = Cartesian3.normalize(cartesian, mostOrthogonalAxisScratch);
Cartesian3.abs(f, f);
if (f.x <= f.y) {
if (f.x <= f.z) {
result = Cartesian3.clone(Cartesian3.UNIT_X, result);
} else {
result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
}
} else {
if (f.y <= f.z) {
result = Cartesian3.clone(Cartesian3.UNIT_Y, result);
} else {
result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
}
}
return result;
};
/**
* Compares the provided Cartesians componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Cartesian3} [left] The first Cartesian.
* @param {Cartesian3} [right] The second Cartesian.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
Cartesian3.equals = function(left, right) {
return (left === right) ||
((defined(left)) &&
(defined(right)) &&
(left.x === right.x) &&
(left.y === right.y) &&
(left.z === right.z));
};
/**
* @private
*/
Cartesian3.equalsArray = function(cartesian, array, offset) {
return cartesian.x === array[offset] &&
cartesian.y === array[offset + 1] &&
cartesian.z === array[offset + 2];
};
/**
* Compares the provided Cartesians componentwise and returns
* <code>true</code> if they pass an absolute or relative tolerance test,
* <code>false</code> otherwise.
*
* @param {Cartesian3} [left] The first Cartesian.
* @param {Cartesian3} [right] The second Cartesian.
* @param {Number} relativeEpsilon The relative epsilon tolerance to use for equality testing.
* @param {Number} [absoluteEpsilon=relativeEpsilon] The absolute epsilon tolerance to use for equality testing.
* @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
*/
Cartesian3.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
return (left === right) ||
(defined(left) &&
defined(right) &&
CesiumMath.equalsEpsilon(left.x, right.x, relativeEpsilon, absoluteEpsilon) &&
CesiumMath.equalsEpsilon(left.y, right.y, relativeEpsilon, absoluteEpsilon) &&
CesiumMath.equalsEpsilon(left.z, right.z, relativeEpsilon, absoluteEpsilon));
};
/**
* Computes the cross (outer) product of two Cartesians.
*
* @param {Cartesian3} left The first Cartesian.
* @param {Cartesian3} right The second Cartesian.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The cross product.
*/
Cartesian3.cross = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
var leftX = left.x;
var leftY = left.y;
var leftZ = left.z;
var rightX = right.x;
var rightY = right.y;
var rightZ = right.z;
var x = leftY * rightZ - leftZ * rightY;
var y = leftZ * rightX - leftX * rightZ;
var z = leftX * rightY - leftY * rightX;
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Returns a Cartesian3 position from longitude and latitude values given in degrees.
*
* @param {Number} longitude The longitude, in degrees
* @param {Number} latitude The latitude, in degrees
* @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The position
*
* @example
* var position = Cesium.Cartesian3.fromDegrees(-115.0, 37.0);
*/
Cartesian3.fromDegrees = function(longitude, latitude, height, ellipsoid, result) {
Check.typeOf.number('longitude', longitude);
Check.typeOf.number('latitude', latitude);
longitude = CesiumMath.toRadians(longitude);
latitude = CesiumMath.toRadians(latitude);
return Cartesian3.fromRadians(longitude, latitude, height, ellipsoid, result);
};
var scratchN = new Cartesian3();
var scratchK = new Cartesian3();
var wgs84RadiiSquared = new Cartesian3(6378137.0 * 6378137.0, 6378137.0 * 6378137.0, 6356752.3142451793 * 6356752.3142451793);
/**
* Returns a Cartesian3 position from longitude and latitude values given in radians.
*
* @param {Number} longitude The longitude, in radians
* @param {Number} latitude The latitude, in radians
* @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The position
*
* @example
* var position = Cesium.Cartesian3.fromRadians(-2.007, 0.645);
*/
Cartesian3.fromRadians = function(longitude, latitude, height, ellipsoid, result) {
Check.typeOf.number('longitude', longitude);
Check.typeOf.number('latitude', latitude);
height = defaultValue(height, 0.0);
var radiiSquared = defined(ellipsoid) ? ellipsoid.radiiSquared : wgs84RadiiSquared;
var cosLatitude = Math.cos(latitude);
scratchN.x = cosLatitude * Math.cos(longitude);
scratchN.y = cosLatitude * Math.sin(longitude);
scratchN.z = Math.sin(latitude);
scratchN = Cartesian3.normalize(scratchN, scratchN);
Cartesian3.multiplyComponents(radiiSquared, scratchN, scratchK);
var gamma = Math.sqrt(Cartesian3.dot(scratchN, scratchK));
scratchK = Cartesian3.divideByScalar(scratchK, gamma, scratchK);
scratchN = Cartesian3.multiplyByScalar(scratchN, height, scratchN);
if (!defined(result)) {
result = new Cartesian3();
}
return Cartesian3.add(scratchK, scratchN, result);
};
/**
* Returns an array of Cartesian3 positions given an array of longitude and latitude values given in degrees.
*
* @param {Number[]} coordinates A list of longitude and latitude values. Values alternate [longitude, latitude, longitude, latitude...].
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the coordinates lie.
* @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
* @returns {Cartesian3[]} The array of positions.
*
* @example
* var positions = Cesium.Cartesian3.fromDegreesArray([-115.0, 37.0, -107.0, 33.0]);
*/
Cartesian3.fromDegreesArray = function(coordinates, ellipsoid, result) {
Check.defined('coordinates', coordinates);
if (coordinates.length < 2 || coordinates.length % 2 !== 0) {
throw new DeveloperError('the number of coordinates must be a multiple of 2 and at least 2');
}
var length = coordinates.length;
if (!defined(result)) {
result = new Array(length / 2);
} else {
result.length = length / 2;
}
for (var i = 0; i < length; i += 2) {
var longitude = coordinates[i];
var latitude = coordinates[i + 1];
var index = i / 2;
result[index] = Cartesian3.fromDegrees(longitude, latitude, 0, ellipsoid, result[index]);
}
return result;
};
/**
* Returns an array of Cartesian3 positions given an array of longitude and latitude values given in radians.
*
* @param {Number[]} coordinates A list of longitude and latitude values. Values alternate [longitude, latitude, longitude, latitude...].
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the coordinates lie.
* @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
* @returns {Cartesian3[]} The array of positions.
*
* @example
* var positions = Cesium.Cartesian3.fromRadiansArray([-2.007, 0.645, -1.867, .575]);
*/
Cartesian3.fromRadiansArray = function(coordinates, ellipsoid, result) {
Check.defined('coordinates', coordinates);
if (coordinates.length < 2 || coordinates.length % 2 !== 0) {
throw new DeveloperError('the number of coordinates must be a multiple of 2 and at least 2');
}
var length = coordinates.length;
if (!defined(result)) {
result = new Array(length / 2);
} else {
result.length = length / 2;
}
for (var i = 0; i < length; i += 2) {
var longitude = coordinates[i];
var latitude = coordinates[i + 1];
var index = i / 2;
result[index] = Cartesian3.fromRadians(longitude, latitude, 0, ellipsoid, result[index]);
}
return result;
};
/**
* Returns an array of Cartesian3 positions given an array of longitude, latitude and height values where longitude and latitude are given in degrees.
*
* @param {Number[]} coordinates A list of longitude, latitude and height values. Values alternate [longitude, latitude, height, longitude, latitude, height...].
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
* @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
* @returns {Cartesian3[]} The array of positions.
*
* @example
* var positions = Cesium.Cartesian3.fromDegreesArrayHeights([-115.0, 37.0, 100000.0, -107.0, 33.0, 150000.0]);
*/
Cartesian3.fromDegreesArrayHeights = function(coordinates, ellipsoid, result) {
Check.defined('coordinates', coordinates);
if (coordinates.length < 3 || coordinates.length % 3 !== 0) {
throw new DeveloperError('the number of coordinates must be a multiple of 3 and at least 3');
}
var length = coordinates.length;
if (!defined(result)) {
result = new Array(length / 3);
} else {
result.length = length / 3;
}
for (var i = 0; i < length; i += 3) {
var longitude = coordinates[i];
var latitude = coordinates[i + 1];
var height = coordinates[i + 2];
var index = i / 3;
result[index] = Cartesian3.fromDegrees(longitude, latitude, height, ellipsoid, result[index]);
}
return result;
};
/**
* Returns an array of Cartesian3 positions given an array of longitude, latitude and height values where longitude and latitude are given in radians.
*
* @param {Number[]} coordinates A list of longitude, latitude and height values. Values alternate [longitude, latitude, height, longitude, latitude, height...].
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
* @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
* @returns {Cartesian3[]} The array of positions.
*
* @example
* var positions = Cesium.Cartesian3.fromRadiansArrayHeights([-2.007, 0.645, 100000.0, -1.867, .575, 150000.0]);
*/
Cartesian3.fromRadiansArrayHeights = function(coordinates, ellipsoid, result) {
Check.defined('coordinates', coordinates);
if (coordinates.length < 3 || coordinates.length % 3 !== 0) {
throw new DeveloperError('the number of coordinates must be a multiple of 3 and at least 3');
}
var length = coordinates.length;
if (!defined(result)) {
result = new Array(length / 3);
} else {
result.length = length / 3;
}
for (var i = 0; i < length; i += 3) {
var longitude = coordinates[i];
var latitude = coordinates[i + 1];
var height = coordinates[i + 2];
var index = i / 3;
result[index] = Cartesian3.fromRadians(longitude, latitude, height, ellipsoid, result[index]);
}
return result;
};
/**
* An immutable Cartesian3 instance initialized to (0.0, 0.0, 0.0).
*
* @type {Cartesian3}
* @constant
*/
Cartesian3.ZERO = freezeObject(new Cartesian3(0.0, 0.0, 0.0));
/**
* An immutable Cartesian3 instance initialized to (1.0, 0.0, 0.0).
*
* @type {Cartesian3}
* @constant
*/
Cartesian3.UNIT_X = freezeObject(new Cartesian3(1.0, 0.0, 0.0));
/**
* An immutable Cartesian3 instance initialized to (0.0, 1.0, 0.0).
*
* @type {Cartesian3}
* @constant
*/
Cartesian3.UNIT_Y = freezeObject(new Cartesian3(0.0, 1.0, 0.0));
/**
* An immutable Cartesian3 instance initialized to (0.0, 0.0, 1.0).
*
* @type {Cartesian3}
* @constant
*/
Cartesian3.UNIT_Z = freezeObject(new Cartesian3(0.0, 0.0, 1.0));
/**
* Duplicates this Cartesian3 instance.
*
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
*/
Cartesian3.prototype.clone = function(result) {
return Cartesian3.clone(this, result);
};
/**
* Compares this Cartesian against the provided Cartesian componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Cartesian3} [right] The right hand side Cartesian.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
Cartesian3.prototype.equals = function(right) {
return Cartesian3.equals(this, right);
};
/**
* Compares this Cartesian against the provided Cartesian componentwise and returns
* <code>true</code> if they pass an absolute or relative tolerance test,
* <code>false</code> otherwise.
*
* @param {Cartesian3} [right] The right hand side Cartesian.
* @param {Number} relativeEpsilon The relative epsilon tolerance to use for equality testing.
* @param {Number} [absoluteEpsilon=relativeEpsilon] The absolute epsilon tolerance to use for equality testing.
* @returns {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
*/
Cartesian3.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
return Cartesian3.equalsEpsilon(this, right, relativeEpsilon, absoluteEpsilon);
};
/**
* Creates a string representing this Cartesian in the format '(x, y, z)'.
*
* @returns {String} A string representing this Cartesian in the format '(x, y, z)'.
*/
Cartesian3.prototype.toString = function() {
return '(' + this.x + ', ' + this.y + ', ' + this.z + ')';
};
return Cartesian3;
});
/*global define*/
define('Core/scaleToGeodeticSurface',[
'./Cartesian3',
'./defined',
'./DeveloperError',
'./Math'
], function(
Cartesian3,
defined,
DeveloperError,
CesiumMath) {
'use strict';
var scaleToGeodeticSurfaceIntersection = new Cartesian3();
var scaleToGeodeticSurfaceGradient = new Cartesian3();
/**
* Scales the provided Cartesian position along the geodetic surface normal
* so that it is on the surface of this ellipsoid. If the position is
* at the center of the ellipsoid, this function returns undefined.
*
* @param {Cartesian3} cartesian The Cartesian position to scale.
* @param {Cartesian3} oneOverRadii One over radii of the ellipsoid.
* @param {Cartesian3} oneOverRadiiSquared One over radii squared of the ellipsoid.
* @param {Number} centerToleranceSquared Tolerance for closeness to the center.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter, a new Cartesian3 instance if none was provided, or undefined if the position is at the center.
*
* @exports scaleToGeodeticSurface
*
* @private
*/
function scaleToGeodeticSurface(cartesian, oneOverRadii, oneOverRadiiSquared, centerToleranceSquared, result) {
if (!defined(cartesian)) {
throw new DeveloperError('cartesian is required.');
}
if (!defined(oneOverRadii)) {
throw new DeveloperError('oneOverRadii is required.');
}
if (!defined(oneOverRadiiSquared)) {
throw new DeveloperError('oneOverRadiiSquared is required.');
}
if (!defined(centerToleranceSquared)) {
throw new DeveloperError('centerToleranceSquared is required.');
}
var positionX = cartesian.x;
var positionY = cartesian.y;
var positionZ = cartesian.z;
var oneOverRadiiX = oneOverRadii.x;
var oneOverRadiiY = oneOverRadii.y;
var oneOverRadiiZ = oneOverRadii.z;
var x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
var y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
var z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
// Compute the squared ellipsoid norm.
var squaredNorm = x2 + y2 + z2;
var ratio = Math.sqrt(1.0 / squaredNorm);
// As an initial approximation, assume that the radial intersection is the projection point.
var intersection = Cartesian3.multiplyByScalar(cartesian, ratio, scaleToGeodeticSurfaceIntersection);
// If the position is near the center, the iteration will not converge.
if (squaredNorm < centerToleranceSquared) {
return !isFinite(ratio) ? undefined : Cartesian3.clone(intersection, result);
}
var oneOverRadiiSquaredX = oneOverRadiiSquared.x;
var oneOverRadiiSquaredY = oneOverRadiiSquared.y;
var oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
// Use the gradient at the intersection point in place of the true unit normal.
// The difference in magnitude will be absorbed in the multiplier.
var gradient = scaleToGeodeticSurfaceGradient;
gradient.x = intersection.x * oneOverRadiiSquaredX * 2.0;
gradient.y = intersection.y * oneOverRadiiSquaredY * 2.0;
gradient.z = intersection.z * oneOverRadiiSquaredZ * 2.0;
// Compute the initial guess at the normal vector multiplier, lambda.
var lambda = (1.0 - ratio) * Cartesian3.magnitude(cartesian) / (0.5 * Cartesian3.magnitude(gradient));
var correction = 0.0;
var func;
var denominator;
var xMultiplier;
var yMultiplier;
var zMultiplier;
var xMultiplier2;
var yMultiplier2;
var zMultiplier2;
var xMultiplier3;
var yMultiplier3;
var zMultiplier3;
do {
lambda -= correction;
xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);
yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);
zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);
xMultiplier2 = xMultiplier * xMultiplier;
yMultiplier2 = yMultiplier * yMultiplier;
zMultiplier2 = zMultiplier * zMultiplier;
xMultiplier3 = xMultiplier2 * xMultiplier;
yMultiplier3 = yMultiplier2 * yMultiplier;
zMultiplier3 = zMultiplier2 * zMultiplier;
func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;
// "denominator" here refers to the use of this expression in the velocity and acceleration
// computations in the sections to follow.
denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
var derivative = -2.0 * denominator;
correction = func / derivative;
} while (Math.abs(func) > CesiumMath.EPSILON12);
if (!defined(result)) {
return new Cartesian3(positionX * xMultiplier, positionY * yMultiplier, positionZ * zMultiplier);
}
result.x = positionX * xMultiplier;
result.y = positionY * yMultiplier;
result.z = positionZ * zMultiplier;
return result;
}
return scaleToGeodeticSurface;
});
/*global define*/
define('Core/Cartographic',[
'./Cartesian3',
'./defaultValue',
'./defined',
'./DeveloperError',
'./freezeObject',
'./Math',
'./scaleToGeodeticSurface'
], function(
Cartesian3,
defaultValue,
defined,
DeveloperError,
freezeObject,
CesiumMath,
scaleToGeodeticSurface) {
'use strict';
/**
* A position defined by longitude, latitude, and height.
* @alias Cartographic
* @constructor
*
* @param {Number} [longitude=0.0] The longitude, in radians.
* @param {Number} [latitude=0.0] The latitude, in radians.
* @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
*
* @see Ellipsoid
*/
function Cartographic(longitude, latitude, height) {
/**
* The longitude, in radians.
* @type {Number}
* @default 0.0
*/
this.longitude = defaultValue(longitude, 0.0);
/**
* The latitude, in radians.
* @type {Number}
* @default 0.0
*/
this.latitude = defaultValue(latitude, 0.0);
/**
* The height, in meters, above the ellipsoid.
* @type {Number}
* @default 0.0
*/
this.height = defaultValue(height, 0.0);
}
/**
* Creates a new Cartographic instance from longitude and latitude
* specified in radians.
*
* @param {Number} longitude The longitude, in radians.
* @param {Number} latitude The latitude, in radians.
* @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
*/
Cartographic.fromRadians = function(longitude, latitude, height, result) {
if (!defined(longitude)) {
throw new DeveloperError('longitude is required.');
}
if (!defined(latitude)) {
throw new DeveloperError('latitude is required.');
}
height = defaultValue(height, 0.0);
if (!defined(result)) {
return new Cartographic(longitude, latitude, height);
}
result.longitude = longitude;
result.latitude = latitude;
result.height = height;
return result;
};
/**
* Creates a new Cartographic instance from longitude and latitude
* specified in degrees. The values in the resulting object will
* be in radians.
*
* @param {Number} longitude The longitude, in degrees.
* @param {Number} latitude The latitude, in degrees.
* @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
*/
Cartographic.fromDegrees = function(longitude, latitude, height, result) {
if (!defined(longitude)) {
throw new DeveloperError('longitude is required.');
}
if (!defined(latitude)) {
throw new DeveloperError('latitude is required.');
}
longitude = CesiumMath.toRadians(longitude);
latitude = CesiumMath.toRadians(latitude);
return Cartographic.fromRadians(longitude, latitude, height, result);
};
var cartesianToCartographicN = new Cartesian3();
var cartesianToCartographicP = new Cartesian3();
var cartesianToCartographicH = new Cartesian3();
var wgs84OneOverRadii = new Cartesian3(1.0 / 6378137.0, 1.0 / 6378137.0, 1.0 / 6356752.3142451793);
var wgs84OneOverRadiiSquared = new Cartesian3(1.0 / (6378137.0 * 6378137.0), 1.0 / (6378137.0 * 6378137.0), 1.0 / (6356752.3142451793 * 6356752.3142451793));
var wgs84CenterToleranceSquared = CesiumMath.EPSILON1;
/**
* Creates a new Cartographic instance from a Cartesian position. The values in the
* resulting object will be in radians.
*
* @param {Cartesian3} cartesian The Cartesian position to convert to cartographic representation.
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter, new Cartographic instance if none was provided, or undefined if the cartesian is at the center of the ellipsoid.
*/
Cartographic.fromCartesian = function(cartesian, ellipsoid, result) {
var oneOverRadii = defined(ellipsoid) ? ellipsoid.oneOverRadii : wgs84OneOverRadii;
var oneOverRadiiSquared = defined(ellipsoid) ? ellipsoid.oneOverRadiiSquared : wgs84OneOverRadiiSquared;
var centerToleranceSquared = defined(ellipsoid) ? ellipsoid._centerToleranceSquared : wgs84CenterToleranceSquared;
//`cartesian is required.` is thrown from scaleToGeodeticSurface
var p = scaleToGeodeticSurface(cartesian, oneOverRadii, oneOverRadiiSquared, centerToleranceSquared, cartesianToCartographicP);
if (!defined(p)) {
return undefined;
}
var n = Cartesian3.multiplyComponents(p, oneOverRadiiSquared, cartesianToCartographicN);
n = Cartesian3.normalize(n, n);
var h = Cartesian3.subtract(cartesian, p, cartesianToCartographicH);
var longitude = Math.atan2(n.y, n.x);
var latitude = Math.asin(n.z);
var height = CesiumMath.sign(Cartesian3.dot(h, cartesian)) * Cartesian3.magnitude(h);
if (!defined(result)) {
return new Cartographic(longitude, latitude, height);
}
result.longitude = longitude;
result.latitude = latitude;
result.height = height;
return result;
};
/**
* Duplicates a Cartographic instance.
*
* @param {Cartographic} cartographic The cartographic to duplicate.
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided. (Returns undefined if cartographic is undefined)
*/
Cartographic.clone = function(cartographic, result) {
if (!defined(cartographic)) {
return undefined;
}
if (!defined(result)) {
return new Cartographic(cartographic.longitude, cartographic.latitude, cartographic.height);
}
result.longitude = cartographic.longitude;
result.latitude = cartographic.latitude;
result.height = cartographic.height;
return result;
};
/**
* Compares the provided cartographics componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Cartographic} [left] The first cartographic.
* @param {Cartographic} [right] The second cartographic.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
Cartographic.equals = function(left, right) {
return (left === right) ||
((defined(left)) &&
(defined(right)) &&
(left.longitude === right.longitude) &&
(left.latitude === right.latitude) &&
(left.height === right.height));
};
/**
* Compares the provided cartographics componentwise and returns
* <code>true</code> if they are within the provided epsilon,
* <code>false</code> otherwise.
*
* @param {Cartographic} [left] The first cartographic.
* @param {Cartographic} [right] The second cartographic.
* @param {Number} epsilon The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
*/
Cartographic.equalsEpsilon = function(left, right, epsilon) {
if (typeof epsilon !== 'number') {
throw new DeveloperError('epsilon is required and must be a number.');
}
return (left === right) ||
((defined(left)) &&
(defined(right)) &&
(Math.abs(left.longitude - right.longitude) <= epsilon) &&
(Math.abs(left.latitude - right.latitude) <= epsilon) &&
(Math.abs(left.height - right.height) <= epsilon));
};
/**
* An immutable Cartographic instance initialized to (0.0, 0.0, 0.0).
*
* @type {Cartographic}
* @constant
*/
Cartographic.ZERO = freezeObject(new Cartographic(0.0, 0.0, 0.0));
/**
* Duplicates this instance.
*
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
*/
Cartographic.prototype.clone = function(result) {
return Cartographic.clone(this, result);
};
/**
* Compares the provided against this cartographic componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Cartographic} [right] The second cartographic.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
Cartographic.prototype.equals = function(right) {
return Cartographic.equals(this, right);
};
/**
* Compares the provided against this cartographic componentwise and returns
* <code>true</code> if they are within the provided epsilon,
* <code>false</code> otherwise.
*
* @param {Cartographic} [right] The second cartographic.
* @param {Number} epsilon The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
*/
Cartographic.prototype.equalsEpsilon = function(right, epsilon) {
return Cartographic.equalsEpsilon(this, right, epsilon);
};
/**
* Creates a string representing this cartographic in the format '(longitude, latitude, height)'.
*
* @returns {String} A string representing the provided cartographic in the format '(longitude, latitude, height)'.
*/
Cartographic.prototype.toString = function() {
return '(' + this.longitude + ', ' + this.latitude + ', ' + this.height + ')';
};
return Cartographic;
});
/*global define*/
define('Core/defineProperties',[
'./defined'
], function(
defined) {
'use strict';
var definePropertyWorks = (function() {
try {
return 'x' in Object.defineProperty({}, 'x', {});
} catch (e) {
return false;
}
})();
/**
* Defines properties on an object, using Object.defineProperties if available,
* otherwise returns the object unchanged. This function should be used in
* setup code to prevent errors from completely halting JavaScript execution
* in legacy browsers.
*
* @private
*
* @exports defineProperties
*/
var defineProperties = Object.defineProperties;
if (!definePropertyWorks || !defined(defineProperties)) {
defineProperties = function(o) {
return o;
};
}
return defineProperties;
});
/*global define*/
define('Core/Ellipsoid',[
'./Cartesian3',
'./Cartographic',
'./defaultValue',
'./defined',
'./defineProperties',
'./DeveloperError',
'./freezeObject',
'./Math',
'./scaleToGeodeticSurface'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
defineProperties,
DeveloperError,
freezeObject,
CesiumMath,
scaleToGeodeticSurface) {
'use strict';
function initialize(ellipsoid, x, y, z) {
x = defaultValue(x, 0.0);
y = defaultValue(y, 0.0);
z = defaultValue(z, 0.0);
if (x < 0.0 || y < 0.0 || z < 0.0) {
throw new DeveloperError('All radii components must be greater than or equal to zero.');
}
ellipsoid._radii = new Cartesian3(x, y, z);
ellipsoid._radiiSquared = new Cartesian3(x * x,
y * y,
z * z);
ellipsoid._radiiToTheFourth = new Cartesian3(x * x * x * x,
y * y * y * y,
z * z * z * z);
ellipsoid._oneOverRadii = new Cartesian3(x === 0.0 ? 0.0 : 1.0 / x,
y === 0.0 ? 0.0 : 1.0 / y,
z === 0.0 ? 0.0 : 1.0 / z);
ellipsoid._oneOverRadiiSquared = new Cartesian3(x === 0.0 ? 0.0 : 1.0 / (x * x),
y === 0.0 ? 0.0 : 1.0 / (y * y),
z === 0.0 ? 0.0 : 1.0 / (z * z));
ellipsoid._minimumRadius = Math.min(x, y, z);
ellipsoid._maximumRadius = Math.max(x, y, z);
ellipsoid._centerToleranceSquared = CesiumMath.EPSILON1;
if (ellipsoid._radiiSquared.z !== 0) {
ellipsoid._sqauredXOverSquaredZ = ellipsoid._radiiSquared.x / ellipsoid._radiiSquared.z;
}
}
/**
* A quadratic surface defined in Cartesian coordinates by the equation
* <code>(x / a)^2 + (y / b)^2 + (z / c)^2 = 1</code>. Primarily used
* by Cesium to represent the shape of planetary bodies.
*
* Rather than constructing this object directly, one of the provided
* constants is normally used.
* @alias Ellipsoid
* @constructor
*
* @param {Number} [x=0] The radius in the x direction.
* @param {Number} [y=0] The radius in the y direction.
* @param {Number} [z=0] The radius in the z direction.
*
* @exception {DeveloperError} All radii components must be greater than or equal to zero.
*
* @see Ellipsoid.fromCartesian3
* @see Ellipsoid.WGS84
* @see Ellipsoid.UNIT_SPHERE
*/
function Ellipsoid(x, y, z) {
this._radii = undefined;
this._radiiSquared = undefined;
this._radiiToTheFourth = undefined;
this._oneOverRadii = undefined;
this._oneOverRadiiSquared = undefined;
this._minimumRadius = undefined;
this._maximumRadius = undefined;
this._centerToleranceSquared = undefined;
this._sqauredXOverSquaredZ = undefined;
initialize(this, x, y, z);
}
defineProperties(Ellipsoid.prototype, {
/**
* Gets the radii of the ellipsoid.
* @memberof Ellipsoid.prototype
* @type {Cartesian3}
* @readonly
*/
radii : {
get: function() {
return this._radii;
}
},
/**
* Gets the squared radii of the ellipsoid.
* @memberof Ellipsoid.prototype
* @type {Cartesian3}
* @readonly
*/
radiiSquared : {
get : function() {
return this._radiiSquared;
}
},
/**
* Gets the radii of the ellipsoid raise to the fourth power.
* @memberof Ellipsoid.prototype
* @type {Cartesian3}
* @readonly
*/
radiiToTheFourth : {
get : function() {
return this._radiiToTheFourth;
}
},
/**
* Gets one over the radii of the ellipsoid.
* @memberof Ellipsoid.prototype
* @type {Cartesian3}
* @readonly
*/
oneOverRadii : {
get : function() {
return this._oneOverRadii;
}
},
/**
* Gets one over the squared radii of the ellipsoid.
* @memberof Ellipsoid.prototype
* @type {Cartesian3}
* @readonly
*/
oneOverRadiiSquared : {
get : function() {
return this._oneOverRadiiSquared;
}
},
/**
* Gets the minimum radius of the ellipsoid.
* @memberof Ellipsoid.prototype
* @type {Number}
* @readonly
*/
minimumRadius : {
get : function() {
return this._minimumRadius;
}
},
/**
* Gets the maximum radius of the ellipsoid.
* @memberof Ellipsoid.prototype
* @type {Number}
* @readonly
*/
maximumRadius : {
get : function() {
return this._maximumRadius;
}
}
});
/**
* Duplicates an Ellipsoid instance.
*
* @param {Ellipsoid} ellipsoid The ellipsoid to duplicate.
* @param {Ellipsoid} [result] The object onto which to store the result, or undefined if a new
* instance should be created.
* @returns {Ellipsoid} The cloned Ellipsoid. (Returns undefined if ellipsoid is undefined)
*/
Ellipsoid.clone = function(ellipsoid, result) {
if (!defined(ellipsoid)) {
return undefined;
}
var radii = ellipsoid._radii;
if (!defined(result)) {
return new Ellipsoid(radii.x, radii.y, radii.z);
}
Cartesian3.clone(radii, result._radii);
Cartesian3.clone(ellipsoid._radiiSquared, result._radiiSquared);
Cartesian3.clone(ellipsoid._radiiToTheFourth, result._radiiToTheFourth);
Cartesian3.clone(ellipsoid._oneOverRadii, result._oneOverRadii);
Cartesian3.clone(ellipsoid._oneOverRadiiSquared, result._oneOverRadiiSquared);
result._minimumRadius = ellipsoid._minimumRadius;
result._maximumRadius = ellipsoid._maximumRadius;
result._centerToleranceSquared = ellipsoid._centerToleranceSquared;
return result;
};
/**
* Computes an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions.
*
* @param {Cartesian3} [cartesian=Cartesian3.ZERO] The ellipsoid's radius in the x, y, and z directions.
* @param {Ellipsoid} [result] The object onto which to store the result, or undefined if a new
* instance should be created.
* @returns {Ellipsoid} A new Ellipsoid instance.
*
* @exception {DeveloperError} All radii components must be greater than or equal to zero.
*
* @see Ellipsoid.WGS84
* @see Ellipsoid.UNIT_SPHERE
*/
Ellipsoid.fromCartesian3 = function(cartesian, result) {
if (!defined(result)) {
result = new Ellipsoid();
}
if (!defined(cartesian)) {
return result;
}
initialize(result, cartesian.x, cartesian.y, cartesian.z);
return result;
};
/**
* An Ellipsoid instance initialized to the WGS84 standard.
*
* @type {Ellipsoid}
* @constant
*/
Ellipsoid.WGS84 = freezeObject(new Ellipsoid(6378137.0, 6378137.0, 6356752.3142451793));
/**
* An Ellipsoid instance initialized to radii of (1.0, 1.0, 1.0).
*
* @type {Ellipsoid}
* @constant
*/
Ellipsoid.UNIT_SPHERE = freezeObject(new Ellipsoid(1.0, 1.0, 1.0));
/**
* An Ellipsoid instance initialized to a sphere with the lunar radius.
*
* @type {Ellipsoid}
* @constant
*/
Ellipsoid.MOON = freezeObject(new Ellipsoid(CesiumMath.LUNAR_RADIUS, CesiumMath.LUNAR_RADIUS, CesiumMath.LUNAR_RADIUS));
/**
* Duplicates an Ellipsoid instance.
*
* @param {Ellipsoid} [result] The object onto which to store the result, or undefined if a new
* instance should be created.
* @returns {Ellipsoid} The cloned Ellipsoid.
*/
Ellipsoid.prototype.clone = function(result) {
return Ellipsoid.clone(this, result);
};
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Ellipsoid.packedLength = Cartesian3.packedLength;
/**
* Stores the provided instance into the provided array.
*
* @param {Ellipsoid} 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
*/
Ellipsoid.pack = function(value, array, startingIndex) {
if (!defined(value)) {
throw new DeveloperError('value is required');
}
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
Cartesian3.pack(value._radii, array, startingIndex);
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 {Ellipsoid} [result] The object into which to store the result.
* @returns {Ellipsoid} The modified result parameter or a new Ellipsoid instance if one was not provided.
*/
Ellipsoid.unpack = function(array, startingIndex, result) {
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
var radii = Cartesian3.unpack(array, startingIndex);
return Ellipsoid.fromCartesian3(radii, result);
};
/**
* Computes the unit vector directed from the center of this ellipsoid toward the provided Cartesian position.
* @function
*
* @param {Cartesian3} cartesian The Cartesian for which to to determine the geocentric normal.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
*/
Ellipsoid.prototype.geocentricSurfaceNormal = Cartesian3.normalize;
/**
* Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position.
*
* @param {Cartographic} cartographic The cartographic position for which to to determine the geodetic normal.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
*/
Ellipsoid.prototype.geodeticSurfaceNormalCartographic = function(cartographic, result) {
if (!defined(cartographic)) {
throw new DeveloperError('cartographic is required.');
}
var longitude = cartographic.longitude;
var latitude = cartographic.latitude;
var cosLatitude = Math.cos(latitude);
var x = cosLatitude * Math.cos(longitude);
var y = cosLatitude * Math.sin(longitude);
var z = Math.sin(latitude);
if (!defined(result)) {
result = new Cartesian3();
}
result.x = x;
result.y = y;
result.z = z;
return Cartesian3.normalize(result, result);
};
/**
* Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position.
*
* @param {Cartesian3} cartesian The Cartesian position for which to to determine the surface normal.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
*/
Ellipsoid.prototype.geodeticSurfaceNormal = function(cartesian, result) {
if (!defined(result)) {
result = new Cartesian3();
}
result = Cartesian3.multiplyComponents(cartesian, this._oneOverRadiiSquared, result);
return Cartesian3.normalize(result, result);
};
var cartographicToCartesianNormal = new Cartesian3();
var cartographicToCartesianK = new Cartesian3();
/**
* Converts the provided cartographic to Cartesian representation.
*
* @param {Cartographic} cartographic The cartographic position.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
*
* @example
* //Create a Cartographic and determine it's Cartesian representation on a WGS84 ellipsoid.
* var position = new Cesium.Cartographic(Cesium.Math.toRadians(21), Cesium.Math.toRadians(78), 5000);
* var cartesianPosition = Cesium.Ellipsoid.WGS84.cartographicToCartesian(position);
*/
Ellipsoid.prototype.cartographicToCartesian = function(cartographic, result) {
//`cartographic is required` is thrown from geodeticSurfaceNormalCartographic.
var n = cartographicToCartesianNormal;
var k = cartographicToCartesianK;
this.geodeticSurfaceNormalCartographic(cartographic, n);
Cartesian3.multiplyComponents(this._radiiSquared, n, k);
var gamma = Math.sqrt(Cartesian3.dot(n, k));
Cartesian3.divideByScalar(k, gamma, k);
Cartesian3.multiplyByScalar(n, cartographic.height, n);
if (!defined(result)) {
result = new Cartesian3();
}
return Cartesian3.add(k, n, result);
};
/**
* Converts the provided array of cartographics to an array of Cartesians.
*
* @param {Cartographic[]} cartographics An array of cartographic positions.
* @param {Cartesian3[]} [result] The object onto which to store the result.
* @returns {Cartesian3[]} The modified result parameter or a new Array instance if none was provided.
*
* @example
* //Convert an array of Cartographics and determine their Cartesian representation on a WGS84 ellipsoid.
* var positions = [new Cesium.Cartographic(Cesium.Math.toRadians(21), Cesium.Math.toRadians(78), 0),
* new Cesium.Cartographic(Cesium.Math.toRadians(21.321), Cesium.Math.toRadians(78.123), 100),
* new Cesium.Cartographic(Cesium.Math.toRadians(21.645), Cesium.Math.toRadians(78.456), 250)];
* var cartesianPositions = Cesium.Ellipsoid.WGS84.cartographicArrayToCartesianArray(positions);
*/
Ellipsoid.prototype.cartographicArrayToCartesianArray = function(cartographics, result) {
if (!defined(cartographics)) {
throw new DeveloperError('cartographics is required.');
}
var length = cartographics.length;
if (!defined(result)) {
result = new Array(length);
} else {
result.length = length;
}
for ( var i = 0; i < length; i++) {
result[i] = this.cartographicToCartesian(cartographics[i], result[i]);
}
return result;
};
var cartesianToCartographicN = new Cartesian3();
var cartesianToCartographicP = new Cartesian3();
var cartesianToCartographicH = new Cartesian3();
/**
* Converts the provided cartesian to cartographic representation.
* The cartesian is undefined at the center of the ellipsoid.
*
* @param {Cartesian3} cartesian The Cartesian position to convert to cartographic representation.
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter, new Cartographic instance if none was provided, or undefined if the cartesian is at the center of the ellipsoid.
*
* @example
* //Create a Cartesian and determine it's Cartographic representation on a WGS84 ellipsoid.
* var position = new Cesium.Cartesian3(17832.12, 83234.52, 952313.73);
* var cartographicPosition = Cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
*/
Ellipsoid.prototype.cartesianToCartographic = function(cartesian, result) {
//`cartesian is required.` is thrown from scaleToGeodeticSurface
var p = this.scaleToGeodeticSurface(cartesian, cartesianToCartographicP);
if (!defined(p)) {
return undefined;
}
var n = this.geodeticSurfaceNormal(p, cartesianToCartographicN);
var h = Cartesian3.subtract(cartesian, p, cartesianToCartographicH);
var longitude = Math.atan2(n.y, n.x);
var latitude = Math.asin(n.z);
var height = CesiumMath.sign(Cartesian3.dot(h, cartesian)) * Cartesian3.magnitude(h);
if (!defined(result)) {
return new Cartographic(longitude, latitude, height);
}
result.longitude = longitude;
result.latitude = latitude;
result.height = height;
return result;
};
/**
* Converts the provided array of cartesians to an array of cartographics.
*
* @param {Cartesian3[]} cartesians An array of Cartesian positions.
* @param {Cartographic[]} [result] The object onto which to store the result.
* @returns {Cartographic[]} The modified result parameter or a new Array instance if none was provided.
*
* @example
* //Create an array of Cartesians and determine their Cartographic representation on a WGS84 ellipsoid.
* var positions = [new Cesium.Cartesian3(17832.12, 83234.52, 952313.73),
* new Cesium.Cartesian3(17832.13, 83234.53, 952313.73),
* new Cesium.Cartesian3(17832.14, 83234.54, 952313.73)]
* var cartographicPositions = Cesium.Ellipsoid.WGS84.cartesianArrayToCartographicArray(positions);
*/
Ellipsoid.prototype.cartesianArrayToCartographicArray = function(cartesians, result) {
if (!defined(cartesians)) {
throw new DeveloperError('cartesians is required.');
}
var length = cartesians.length;
if (!defined(result)) {
result = new Array(length);
} else {
result.length = length;
}
for ( var i = 0; i < length; ++i) {
result[i] = this.cartesianToCartographic(cartesians[i], result[i]);
}
return result;
};
/**
* Scales the provided Cartesian position along the geodetic surface normal
* so that it is on the surface of this ellipsoid. If the position is
* at the center of the ellipsoid, this function returns undefined.
*
* @param {Cartesian3} cartesian The Cartesian position to scale.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter, a new Cartesian3 instance if none was provided, or undefined if the position is at the center.
*/
Ellipsoid.prototype.scaleToGeodeticSurface = function(cartesian, result) {
return scaleToGeodeticSurface(cartesian, this._oneOverRadii, this._oneOverRadiiSquared, this._centerToleranceSquared, result);
};
/**
* Scales the provided Cartesian position along the geocentric surface normal
* so that it is on the surface of this ellipsoid.
*
* @param {Cartesian3} cartesian The Cartesian position to scale.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
*/
Ellipsoid.prototype.scaleToGeocentricSurface = function(cartesian, result) {
if (!defined(cartesian)) {
throw new DeveloperError('cartesian is required.');
}
if (!defined(result)) {
result = new Cartesian3();
}
var positionX = cartesian.x;
var positionY = cartesian.y;
var positionZ = cartesian.z;
var oneOverRadiiSquared = this._oneOverRadiiSquared;
var beta = 1.0 / Math.sqrt((positionX * positionX) * oneOverRadiiSquared.x +
(positionY * positionY) * oneOverRadiiSquared.y +
(positionZ * positionZ) * oneOverRadiiSquared.z);
return Cartesian3.multiplyByScalar(cartesian, beta, result);
};
/**
* Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
* its components by the result of {@link Ellipsoid#oneOverRadii}.
*
* @param {Cartesian3} position The position to transform.
* @param {Cartesian3} [result] The position to which to copy the result, or undefined to create and
* return a new instance.
* @returns {Cartesian3} The position expressed in the scaled space. The returned instance is the
* one passed as the result parameter if it is not undefined, or a new instance of it is.
*/
Ellipsoid.prototype.transformPositionToScaledSpace = function(position, result) {
if (!defined(result)) {
result = new Cartesian3();
}
return Cartesian3.multiplyComponents(position, this._oneOverRadii, result);
};
/**
* Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
* its components by the result of {@link Ellipsoid#radii}.
*
* @param {Cartesian3} position The position to transform.
* @param {Cartesian3} [result] The position to which to copy the result, or undefined to create and
* return a new instance.
* @returns {Cartesian3} The position expressed in the unscaled space. The returned instance is the
* one passed as the result parameter if it is not undefined, or a new instance of it is.
*/
Ellipsoid.prototype.transformPositionFromScaledSpace = function(position, result) {
if (!defined(result)) {
result = new Cartesian3();
}
return Cartesian3.multiplyComponents(position, this._radii, result);
};
/**
* Compares this Ellipsoid against the provided Ellipsoid componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Ellipsoid} [right] The other Ellipsoid.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
Ellipsoid.prototype.equals = function(right) {
return (this === right) ||
(defined(right) &&
Cartesian3.equals(this._radii, right._radii));
};
/**
* Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'.
*
* @returns {String} A string representing this ellipsoid in the format '(radii.x, radii.y, radii.z)'.
*/
Ellipsoid.prototype.toString = function() {
return this._radii.toString();
};
/**
* Computes a point which is the intersection of the surface normal with the z-axis.
*
* @param {Cartesian3} position the position. must be on the surface of the ellipsoid.
* @param {Number} [buffer = 0.0] A buffer to subtract from the ellipsoid size when checking if the point is inside the ellipsoid.
* In earth case, with common earth datums, there is no need for this buffer since the intersection point is always (relatively) very close to the center.
* In WGS84 datum, intersection point is at max z = +-42841.31151331382 (0.673% of z-axis).
* Intersection point could be outside the ellipsoid if the ratio of MajorAxis / AxisOfRotation is bigger than the square root of 2
* @param {Cartesian} [result] The cartesian to which to copy the result, or undefined to create and
* return a new instance.
* @returns {Cartesian | undefined} the intersection point if it's inside the ellipsoid, undefined otherwise
*
* @exception {DeveloperError} position is required.
* @exception {DeveloperError} Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y).
* @exception {DeveloperError} Ellipsoid.radii.z must be greater than 0.
*/
Ellipsoid.prototype.getSurfaceNormalIntersectionWithZAxis = function(position, buffer, result) {
if (!defined(position)) {
throw new DeveloperError('position is required.');
}
if (!CesiumMath.equalsEpsilon(this._radii.x, this._radii.y, CesiumMath.EPSILON15)) {
throw new DeveloperError('Ellipsoid must be an ellipsoid of revolution (radii.x == radii.y)');
}
if (this._radii.z === 0) {
throw new DeveloperError('Ellipsoid.radii.z must be greater than 0');
}
buffer = defaultValue(buffer, 0.0);
var sqauredXOverSquaredZ = this._sqauredXOverSquaredZ;
if (!defined(result)) {
result = new Cartesian3();
}
result.x = 0.0;
result.y = 0.0;
result.z = position.z * (1 - sqauredXOverSquaredZ);
if (Math.abs(result.z) >= this._radii.z - buffer) {
return undefined;
}
return result;
};
return Ellipsoid;
});
/*global define*/
define('Core/arrayRemoveDuplicates',[
'./defaultValue',
'./defined',
'./DeveloperError',
'./Math'
], function(
defaultValue,
defined,
DeveloperError,
CesiumMath) {
'use strict';
var removeDuplicatesEpsilon = CesiumMath.EPSILON10;
/**
* Removes adjacent duplicate values in an array of values.
*
* @param {Object[]} [values] The array of values.
* @param {Function} equalsEpsilon Function to compare values with an epsilon. Boolean equalsEpsilon(left, right, epsilon).
* @param {Boolean} [wrapAround=false] Compare the last value in the array against the first value.
* @returns {Object[]|undefined} A new array of values with no adjacent duplicate values or the input array if no duplicates were found.
*
* @example
* // Returns [(1.0, 1.0, 1.0), (2.0, 2.0, 2.0), (3.0, 3.0, 3.0), (1.0, 1.0, 1.0)]
* var values = [
* new Cesium.Cartesian3(1.0, 1.0, 1.0),
* new Cesium.Cartesian3(1.0, 1.0, 1.0),
* new Cesium.Cartesian3(2.0, 2.0, 2.0),
* new Cesium.Cartesian3(3.0, 3.0, 3.0),
* new Cesium.Cartesian3(1.0, 1.0, 1.0)];
* var nonDuplicatevalues = Cesium.PolylinePipeline.removeDuplicates(values, Cartesian3.equalsEpsilon);
*
* @example
* // Returns [(1.0, 1.0, 1.0), (2.0, 2.0, 2.0), (3.0, 3.0, 3.0)]
* var values = [
* new Cesium.Cartesian3(1.0, 1.0, 1.0),
* new Cesium.Cartesian3(1.0, 1.0, 1.0),
* new Cesium.Cartesian3(2.0, 2.0, 2.0),
* new Cesium.Cartesian3(3.0, 3.0, 3.0),
* new Cesium.Cartesian3(1.0, 1.0, 1.0)];
* var nonDuplicatevalues = Cesium.PolylinePipeline.removeDuplicates(values, Cartesian3.equalsEpsilon, true);
*
* @private
*/
function arrayRemoveDuplicates(values, equalsEpsilon, wrapAround) {
if (!defined(equalsEpsilon)) {
throw new DeveloperError('equalsEpsilon is required.');
}
if (!defined(values)) {
return undefined;
}
wrapAround = defaultValue(wrapAround, false);
var length = values.length;
if (length < 2) {
return values;
}
var i;
var v0;
var v1;
for (i = 1; i < length; ++i) {
v0 = values[i - 1];
v1 = values[i];
if (equalsEpsilon(v0, v1, removeDuplicatesEpsilon)) {
break;
}
}
if (i === length) {
if (wrapAround && equalsEpsilon(values[0], values[values.length - 1], removeDuplicatesEpsilon)) {
return values.slice(1);
}
return values;
}
var cleanedvalues = values.slice(0, i);
for (; i < length; ++i) {
// v0 is set by either the previous loop, or the previous clean point.
v1 = values[i];
if (!equalsEpsilon(v0, v1, removeDuplicatesEpsilon)) {
cleanedvalues.push(v1);
v0 = v1;
}
}
if (wrapAround && cleanedvalues.length > 1 && equalsEpsilon(cleanedvalues[0], cleanedvalues[cleanedvalues.length - 1], removeDuplicatesEpsilon)) {
cleanedvalues.shift();
}
return cleanedvalues;
}
return arrayRemoveDuplicates;
});
/*global define*/
define('Core/GeographicProjection',[
'./Cartesian3',
'./Cartographic',
'./defaultValue',
'./defined',
'./defineProperties',
'./DeveloperError',
'./Ellipsoid'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
defineProperties,
DeveloperError,
Ellipsoid) {
'use strict';
/**
* A simple map projection where longitude and latitude are linearly mapped to X and Y by multiplying
* them by the {@link Ellipsoid#maximumRadius}. This projection
* is commonly known as geographic, equirectangular, equidistant cylindrical, or plate carrée. It
* is also known as EPSG:4326.
*
* @alias GeographicProjection
* @constructor
*
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid.
*
* @see WebMercatorProjection
*/
function GeographicProjection(ellipsoid) {
this._ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
this._semimajorAxis = this._ellipsoid.maximumRadius;
this._oneOverSemimajorAxis = 1.0 / this._semimajorAxis;
}
defineProperties(GeographicProjection.prototype, {
/**
* Gets the {@link Ellipsoid}.
*
* @memberof GeographicProjection.prototype
*
* @type {Ellipsoid}
* @readonly
*/
ellipsoid : {
get : function() {
return this._ellipsoid;
}
}
});
/**
* Projects a set of {@link Cartographic} coordinates, in radians, to map coordinates, in meters.
* X and Y are the longitude and latitude, respectively, multiplied by the maximum radius of the
* ellipsoid. Z is the unmodified height.
*
* @param {Cartographic} cartographic The coordinates to project.
* @param {Cartesian3} [result] An instance into which to copy the result. If this parameter is
* undefined, a new instance is created and returned.
* @returns {Cartesian3} The projected coordinates. If the result parameter is not undefined, the
* coordinates are copied there and that instance is returned. Otherwise, a new instance is
* created and returned.
*/
GeographicProjection.prototype.project = function(cartographic, result) {
// Actually this is the special case of equidistant cylindrical called the plate carree
var semimajorAxis = this._semimajorAxis;
var x = cartographic.longitude * semimajorAxis;
var y = cartographic.latitude * semimajorAxis;
var z = cartographic.height;
if (!defined(result)) {
return new Cartesian3(x, y, z);
}
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Unprojects a set of projected {@link Cartesian3} coordinates, in meters, to {@link Cartographic}
* coordinates, in radians. Longitude and Latitude are the X and Y coordinates, respectively,
* divided by the maximum radius of the ellipsoid. Height is the unmodified Z coordinate.
*
* @param {Cartesian3} cartesian The Cartesian position to unproject with height (z) in meters.
* @param {Cartographic} [result] An instance into which to copy the result. If this parameter is
* undefined, a new instance is created and returned.
* @returns {Cartographic} The unprojected coordinates. If the result parameter is not undefined, the
* coordinates are copied there and that instance is returned. Otherwise, a new instance is
* created and returned.
*/
GeographicProjection.prototype.unproject = function(cartesian, result) {
if (!defined(cartesian)) {
throw new DeveloperError('cartesian is required');
}
var oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
var longitude = cartesian.x * oneOverEarthSemimajorAxis;
var latitude = cartesian.y * oneOverEarthSemimajorAxis;
var height = cartesian.z;
if (!defined(result)) {
return new Cartographic(longitude, latitude, height);
}
result.longitude = longitude;
result.latitude = latitude;
result.height = height;
return result;
};
return GeographicProjection;
});
/*global define*/
define('Core/Intersect',[
'./freezeObject'
], function(
freezeObject) {
'use strict';
/**
* This enumerated type is used in determining where, relative to the frustum, an
* object is located. The object can either be fully contained within the frustum (INSIDE),
* partially inside the frustum and partially outside (INTERSECTING), or somwhere entirely
* outside of the frustum's 6 planes (OUTSIDE).
*
* @exports Intersect
*/
var Intersect = {
/**
* Represents that an object is not contained within the frustum.
*
* @type {Number}
* @constant
*/
OUTSIDE : -1,
/**
* Represents that an object intersects one of the frustum's planes.
*
* @type {Number}
* @constant
*/
INTERSECTING : 0,
/**
* Represents that an object is fully within the frustum.
*
* @type {Number}
* @constant
*/
INSIDE : 1
};
return freezeObject(Intersect);
});
/*global define*/
define('Core/Interval',[
'./defaultValue'
], function(
defaultValue) {
'use strict';
/**
* Represents the closed interval [start, stop].
* @alias Interval
* @constructor
*
* @param {Number} [start=0.0] The beginning of the interval.
* @param {Number} [stop=0.0] The end of the interval.
*/
function Interval(start, stop) {
/**
* The beginning of the interval.
* @type {Number}
* @default 0.0
*/
this.start = defaultValue(start, 0.0);
/**
* The end of the interval.
* @type {Number}
* @default 0.0
*/
this.stop = defaultValue(stop, 0.0);
}
return Interval;
});
/*global define*/
define('Core/Matrix3',[
'./Cartesian3',
'./Check',
'./defaultValue',
'./defined',
'./defineProperties',
'./DeveloperError',
'./freezeObject',
'./Math'
], function(
Cartesian3,
Check,
defaultValue,
defined,
defineProperties,
DeveloperError,
freezeObject,
CesiumMath) {
'use strict';
/**
* A 3x3 matrix, indexable as a column-major order array.
* Constructor parameters are in row-major order for code readability.
* @alias Matrix3
* @constructor
*
* @param {Number} [column0Row0=0.0] The value for column 0, row 0.
* @param {Number} [column1Row0=0.0] The value for column 1, row 0.
* @param {Number} [column2Row0=0.0] The value for column 2, row 0.
* @param {Number} [column0Row1=0.0] The value for column 0, row 1.
* @param {Number} [column1Row1=0.0] The value for column 1, row 1.
* @param {Number} [column2Row1=0.0] The value for column 2, row 1.
* @param {Number} [column0Row2=0.0] The value for column 0, row 2.
* @param {Number} [column1Row2=0.0] The value for column 1, row 2.
* @param {Number} [column2Row2=0.0] The value for column 2, row 2.
*
* @see Matrix3.fromColumnMajorArray
* @see Matrix3.fromRowMajorArray
* @see Matrix3.fromQuaternion
* @see Matrix3.fromScale
* @see Matrix3.fromUniformScale
* @see Matrix2
* @see Matrix4
*/
function Matrix3(column0Row0, column1Row0, column2Row0,
column0Row1, column1Row1, column2Row1,
column0Row2, column1Row2, column2Row2) {
this[0] = defaultValue(column0Row0, 0.0);
this[1] = defaultValue(column0Row1, 0.0);
this[2] = defaultValue(column0Row2, 0.0);
this[3] = defaultValue(column1Row0, 0.0);
this[4] = defaultValue(column1Row1, 0.0);
this[5] = defaultValue(column1Row2, 0.0);
this[6] = defaultValue(column2Row0, 0.0);
this[7] = defaultValue(column2Row1, 0.0);
this[8] = defaultValue(column2Row2, 0.0);
}
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Matrix3.packedLength = 9;
/**
* Stores the provided instance into the provided array.
*
* @param {Matrix3} 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
*/
Matrix3.pack = function(value, array, startingIndex) {
Check.typeOf.object('value', value);
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value[0];
array[startingIndex++] = value[1];
array[startingIndex++] = value[2];
array[startingIndex++] = value[3];
array[startingIndex++] = value[4];
array[startingIndex++] = value[5];
array[startingIndex++] = value[6];
array[startingIndex++] = value[7];
array[startingIndex++] = value[8];
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 {Matrix3} [result] The object into which to store the result.
* @returns {Matrix3} The modified result parameter or a new Matrix3 instance if one was not provided.
*/
Matrix3.unpack = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Matrix3();
}
result[0] = array[startingIndex++];
result[1] = array[startingIndex++];
result[2] = array[startingIndex++];
result[3] = array[startingIndex++];
result[4] = array[startingIndex++];
result[5] = array[startingIndex++];
result[6] = array[startingIndex++];
result[7] = array[startingIndex++];
result[8] = array[startingIndex++];
return result;
};
/**
* Duplicates a Matrix3 instance.
*
* @param {Matrix3} matrix The matrix to duplicate.
* @param {Matrix3} [result] The object onto which to store the result.
* @returns {Matrix3} The modified result parameter or a new Matrix3 instance if one was not provided. (Returns undefined if matrix is undefined)
*/
Matrix3.clone = function(matrix, result) {
if (!defined(matrix)) {
return undefined;
}
if (!defined(result)) {
return new Matrix3(matrix[0], matrix[3], matrix[6],
matrix[1], matrix[4], matrix[7],
matrix[2], matrix[5], matrix[8]);
}
result[0] = matrix[0];
result[1] = matrix[1];
result[2] = matrix[2];
result[3] = matrix[3];
result[4] = matrix[4];
result[5] = matrix[5];
result[6] = matrix[6];
result[7] = matrix[7];
result[8] = matrix[8];
return result;
};
/**
* Creates a Matrix3 from 9 consecutive elements in an array.
*
* @param {Number[]} array The array whose 9 consecutive elements correspond to the positions of the matrix. Assumes column-major order.
* @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to first column first row position in the matrix.
* @param {Matrix3} [result] The object onto which to store the result.
* @returns {Matrix3} The modified result parameter or a new Matrix3 instance if one was not provided.
*
* @example
* // Create the Matrix3:
* // [1.0, 2.0, 3.0]
* // [1.0, 2.0, 3.0]
* // [1.0, 2.0, 3.0]
*
* var v = [1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0];
* var m = Cesium.Matrix3.fromArray(v);
*
* // Create same Matrix3 with using an offset into an array
* var v2 = [0.0, 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0];
* var m2 = Cesium.Matrix3.fromArray(v2, 2);
*/
Matrix3.fromArray = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Matrix3();
}
result[0] = array[startingIndex];
result[1] = array[startingIndex + 1];
result[2] = array[startingIndex + 2];
result[3] = array[startingIndex + 3];
result[4] = array[startingIndex + 4];
result[5] = array[startingIndex + 5];
result[6] = array[startingIndex + 6];
result[7] = array[startingIndex + 7];
result[8] = array[startingIndex + 8];
return result;
};
/**
* Creates a Matrix3 instance from a column-major order array.
*
* @param {Number[]} values The column-major order array.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*/
Matrix3.fromColumnMajorArray = function(values, result) {
Check.defined('values', values);
return Matrix3.clone(values, result);
};
/**
* Creates a Matrix3 instance from a row-major order array.
* The resulting matrix will be in column-major order.
*
* @param {Number[]} values The row-major order array.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*/
Matrix3.fromRowMajorArray = function(values, result) {
Check.defined('values', values);
if (!defined(result)) {
return new Matrix3(values[0], values[1], values[2],
values[3], values[4], values[5],
values[6], values[7], values[8]);
}
result[0] = values[0];
result[1] = values[3];
result[2] = values[6];
result[3] = values[1];
result[4] = values[4];
result[5] = values[7];
result[6] = values[2];
result[7] = values[5];
result[8] = values[8];
return result;
};
/**
* Computes a 3x3 rotation matrix from the provided quaternion.
*
* @param {Quaternion} quaternion the quaternion to use.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The 3x3 rotation matrix from this quaternion.
*/
Matrix3.fromQuaternion = function(quaternion, result) {
Check.typeOf.object('quaternion', quaternion);
var x2 = quaternion.x * quaternion.x;
var xy = quaternion.x * quaternion.y;
var xz = quaternion.x * quaternion.z;
var xw = quaternion.x * quaternion.w;
var y2 = quaternion.y * quaternion.y;
var yz = quaternion.y * quaternion.z;
var yw = quaternion.y * quaternion.w;
var z2 = quaternion.z * quaternion.z;
var zw = quaternion.z * quaternion.w;
var w2 = quaternion.w * quaternion.w;
var m00 = x2 - y2 - z2 + w2;
var m01 = 2.0 * (xy - zw);
var m02 = 2.0 * (xz + yw);
var m10 = 2.0 * (xy + zw);
var m11 = -x2 + y2 - z2 + w2;
var m12 = 2.0 * (yz - xw);
var m20 = 2.0 * (xz - yw);
var m21 = 2.0 * (yz + xw);
var m22 = -x2 - y2 + z2 + w2;
if (!defined(result)) {
return new Matrix3(m00, m01, m02,
m10, m11, m12,
m20, m21, m22);
}
result[0] = m00;
result[1] = m10;
result[2] = m20;
result[3] = m01;
result[4] = m11;
result[5] = m21;
result[6] = m02;
result[7] = m12;
result[8] = m22;
return result;
};
/**
* Computes a 3x3 rotation matrix from the provided headingPitchRoll. (see http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles )
*
* @param {HeadingPitchRoll} headingPitchRoll the headingPitchRoll to use.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The 3x3 rotation matrix from this headingPitchRoll.
*/
Matrix3.fromHeadingPitchRoll = function(headingPitchRoll, result) {
Check.typeOf.object('headingPitchRoll', headingPitchRoll);
var cosTheta = Math.cos(-headingPitchRoll.pitch);
var cosPsi = Math.cos(-headingPitchRoll.heading);
var cosPhi = Math.cos(headingPitchRoll.roll);
var sinTheta = Math.sin(-headingPitchRoll.pitch);
var sinPsi = Math.sin(-headingPitchRoll.heading);
var sinPhi = Math.sin(headingPitchRoll.roll);
var m00 = cosTheta * cosPsi;
var m01 = -cosPhi * sinPsi + sinPhi * sinTheta * cosPsi;
var m02 = sinPhi * sinPsi + cosPhi * sinTheta * cosPsi;
var m10 = cosTheta * sinPsi;
var m11 = cosPhi * cosPsi + sinPhi * sinTheta * sinPsi;
var m12 = -sinPhi * cosPsi + cosPhi * sinTheta * sinPsi;
var m20 = -sinTheta;
var m21 = sinPhi * cosTheta;
var m22 = cosPhi * cosTheta;
if (!defined(result)) {
return new Matrix3(m00, m01, m02,
m10, m11, m12,
m20, m21, m22);
}
result[0] = m00;
result[1] = m10;
result[2] = m20;
result[3] = m01;
result[4] = m11;
result[5] = m21;
result[6] = m02;
result[7] = m12;
result[8] = m22;
return result;
};
/**
* Computes a Matrix3 instance representing a non-uniform scale.
*
* @param {Cartesian3} scale The x, y, and z scale factors.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*
* @example
* // Creates
* // [7.0, 0.0, 0.0]
* // [0.0, 8.0, 0.0]
* // [0.0, 0.0, 9.0]
* var m = Cesium.Matrix3.fromScale(new Cesium.Cartesian3(7.0, 8.0, 9.0));
*/
Matrix3.fromScale = function(scale, result) {
Check.typeOf.object('scale', scale);
if (!defined(result)) {
return new Matrix3(
scale.x, 0.0, 0.0,
0.0, scale.y, 0.0,
0.0, 0.0, scale.z);
}
result[0] = scale.x;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = scale.y;
result[5] = 0.0;
result[6] = 0.0;
result[7] = 0.0;
result[8] = scale.z;
return result;
};
/**
* Computes a Matrix3 instance representing a uniform scale.
*
* @param {Number} scale The uniform scale factor.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*
* @example
* // Creates
* // [2.0, 0.0, 0.0]
* // [0.0, 2.0, 0.0]
* // [0.0, 0.0, 2.0]
* var m = Cesium.Matrix3.fromUniformScale(2.0);
*/
Matrix3.fromUniformScale = function(scale, result) {
Check.typeOf.number('scale', scale);
if (!defined(result)) {
return new Matrix3(
scale, 0.0, 0.0,
0.0, scale, 0.0,
0.0, 0.0, scale);
}
result[0] = scale;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = scale;
result[5] = 0.0;
result[6] = 0.0;
result[7] = 0.0;
result[8] = scale;
return result;
};
/**
* Computes a Matrix3 instance representing the cross product equivalent matrix of a Cartesian3 vector.
*
* @param {Cartesian3} vector the vector on the left hand side of the cross product operation.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*
* @example
* // Creates
* // [0.0, -9.0, 8.0]
* // [9.0, 0.0, -7.0]
* // [-8.0, 7.0, 0.0]
* var m = Cesium.Matrix3.fromCrossProduct(new Cesium.Cartesian3(7.0, 8.0, 9.0));
*/
Matrix3.fromCrossProduct = function(vector, result) {
Check.typeOf.object('vector', vector);
if (!defined(result)) {
return new Matrix3(
0.0, -vector.z, vector.y,
vector.z, 0.0, -vector.x,
-vector.y, vector.x, 0.0);
}
result[0] = 0.0;
result[1] = vector.z;
result[2] = -vector.y;
result[3] = -vector.z;
result[4] = 0.0;
result[5] = vector.x;
result[6] = vector.y;
result[7] = -vector.x;
result[8] = 0.0;
return result;
};
/**
* Creates a rotation matrix around the x-axis.
*
* @param {Number} angle The angle, in radians, of the rotation. Positive angles are counterclockwise.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*
* @example
* // Rotate a point 45 degrees counterclockwise around the x-axis.
* var p = new Cesium.Cartesian3(5, 6, 7);
* var m = Cesium.Matrix3.fromRotationX(Cesium.Math.toRadians(45.0));
* var rotated = Cesium.Matrix3.multiplyByVector(m, p, new Cesium.Cartesian3());
*/
Matrix3.fromRotationX = function(angle, result) {
Check.typeOf.number('angle', angle);
var cosAngle = Math.cos(angle);
var sinAngle = Math.sin(angle);
if (!defined(result)) {
return new Matrix3(
1.0, 0.0, 0.0,
0.0, cosAngle, -sinAngle,
0.0, sinAngle, cosAngle);
}
result[0] = 1.0;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = cosAngle;
result[5] = sinAngle;
result[6] = 0.0;
result[7] = -sinAngle;
result[8] = cosAngle;
return result;
};
/**
* Creates a rotation matrix around the y-axis.
*
* @param {Number} angle The angle, in radians, of the rotation. Positive angles are counterclockwise.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*
* @example
* // Rotate a point 45 degrees counterclockwise around the y-axis.
* var p = new Cesium.Cartesian3(5, 6, 7);
* var m = Cesium.Matrix3.fromRotationY(Cesium.Math.toRadians(45.0));
* var rotated = Cesium.Matrix3.multiplyByVector(m, p, new Cesium.Cartesian3());
*/
Matrix3.fromRotationY = function(angle, result) {
Check.typeOf.number('angle', angle);
var cosAngle = Math.cos(angle);
var sinAngle = Math.sin(angle);
if (!defined(result)) {
return new Matrix3(
cosAngle, 0.0, sinAngle,
0.0, 1.0, 0.0,
-sinAngle, 0.0, cosAngle);
}
result[0] = cosAngle;
result[1] = 0.0;
result[2] = -sinAngle;
result[3] = 0.0;
result[4] = 1.0;
result[5] = 0.0;
result[6] = sinAngle;
result[7] = 0.0;
result[8] = cosAngle;
return result;
};
/**
* Creates a rotation matrix around the z-axis.
*
* @param {Number} angle The angle, in radians, of the rotation. Positive angles are counterclockwise.
* @param {Matrix3} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix3} The modified result parameter, or a new Matrix3 instance if one was not provided.
*
* @example
* // Rotate a point 45 degrees counterclockwise around the z-axis.
* var p = new Cesium.Cartesian3(5, 6, 7);
* var m = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(45.0));
* var rotated = Cesium.Matrix3.multiplyByVector(m, p, new Cesium.Cartesian3());
*/
Matrix3.fromRotationZ = function(angle, result) {
Check.typeOf.number('angle', angle);
var cosAngle = Math.cos(angle);
var sinAngle = Math.sin(angle);
if (!defined(result)) {
return new Matrix3(
cosAngle, -sinAngle, 0.0,
sinAngle, cosAngle, 0.0,
0.0, 0.0, 1.0);
}
result[0] = cosAngle;
result[1] = sinAngle;
result[2] = 0.0;
result[3] = -sinAngle;
result[4] = cosAngle;
result[5] = 0.0;
result[6] = 0.0;
result[7] = 0.0;
result[8] = 1.0;
return result;
};
/**
* Creates an Array from the provided Matrix3 instance.
* The array will be in column-major order.
*
* @param {Matrix3} matrix The matrix to use..
* @param {Number[]} [result] The Array onto which to store the result.
* @returns {Number[]} The modified Array parameter or a new Array instance if one was not provided.
*/
Matrix3.toArray = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
if (!defined(result)) {
return [matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5], matrix[6], matrix[7], matrix[8]];
}
result[0] = matrix[0];
result[1] = matrix[1];
result[2] = matrix[2];
result[3] = matrix[3];
result[4] = matrix[4];
result[5] = matrix[5];
result[6] = matrix[6];
result[7] = matrix[7];
result[8] = matrix[8];
return result;
};
/**
* Computes the array index of the element at the provided row and column.
*
* @param {Number} row The zero-based index of the row.
* @param {Number} column The zero-based index of the column.
* @returns {Number} The index of the element at the provided row and column.
*
* @exception {DeveloperError} row must be 0, 1, or 2.
* @exception {DeveloperError} column must be 0, 1, or 2.
*
* @example
* var myMatrix = new Cesium.Matrix3();
* var column1Row0Index = Cesium.Matrix3.getElementIndex(1, 0);
* var column1Row0 = myMatrix[column1Row0Index]
* myMatrix[column1Row0Index] = 10.0;
*/
Matrix3.getElementIndex = function(column, row) {
Check.typeOf.number.greaterThanOrEquals('row', row, 0);
Check.typeOf.number.lessThanOrEquals('row', row, 2);
Check.typeOf.number.greaterThanOrEquals('column', column, 0);
Check.typeOf.number.lessThanOrEquals('column', column, 2);
return column * 3 + row;
};
/**
* Retrieves a copy of the matrix column at the provided index as a Cartesian3 instance.
*
* @param {Matrix3} matrix The matrix to use.
* @param {Number} index The zero-based index of the column to retrieve.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, or 2.
*/
Matrix3.getColumn = function(matrix, index, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 2);
Check.typeOf.object('result', result);
var startIndex = index * 3;
var x = matrix[startIndex];
var y = matrix[startIndex + 1];
var z = matrix[startIndex + 2];
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Computes a new matrix that replaces the specified column in the provided matrix with the provided Cartesian3 instance.
*
* @param {Matrix3} matrix The matrix to use.
* @param {Number} index The zero-based index of the column to set.
* @param {Cartesian3} cartesian The Cartesian whose values will be assigned to the specified column.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, or 2.
*/
Matrix3.setColumn = function(matrix, index, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 2);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result = Matrix3.clone(matrix, result);
var startIndex = index * 3;
result[startIndex] = cartesian.x;
result[startIndex + 1] = cartesian.y;
result[startIndex + 2] = cartesian.z;
return result;
};
/**
* Retrieves a copy of the matrix row at the provided index as a Cartesian3 instance.
*
* @param {Matrix3} matrix The matrix to use.
* @param {Number} index The zero-based index of the row to retrieve.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, or 2.
*/
Matrix3.getRow = function(matrix, index, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 2);
Check.typeOf.object('result', result);
var x = matrix[index];
var y = matrix[index + 3];
var z = matrix[index + 6];
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Computes a new matrix that replaces the specified row in the provided matrix with the provided Cartesian3 instance.
*
* @param {Matrix3} matrix The matrix to use.
* @param {Number} index The zero-based index of the row to set.
* @param {Cartesian3} cartesian The Cartesian whose values will be assigned to the specified row.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, or 2.
*/
Matrix3.setRow = function(matrix, index, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 2);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result = Matrix3.clone(matrix, result);
result[index] = cartesian.x;
result[index + 3] = cartesian.y;
result[index + 6] = cartesian.z;
return result;
};
var scratchColumn = new Cartesian3();
/**
* Extracts the non-uniform scale assuming the matrix is an affine transformation.
*
* @param {Matrix3} matrix The matrix.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Matrix3.getScale = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result.x = Cartesian3.magnitude(Cartesian3.fromElements(matrix[0], matrix[1], matrix[2], scratchColumn));
result.y = Cartesian3.magnitude(Cartesian3.fromElements(matrix[3], matrix[4], matrix[5], scratchColumn));
result.z = Cartesian3.magnitude(Cartesian3.fromElements(matrix[6], matrix[7], matrix[8], scratchColumn));
return result;
};
var scratchScale = new Cartesian3();
/**
* Computes the maximum scale assuming the matrix is an affine transformation.
* The maximum scale is the maximum length of the column vectors.
*
* @param {Matrix3} matrix The matrix.
* @returns {Number} The maximum scale.
*/
Matrix3.getMaximumScale = function(matrix) {
Matrix3.getScale(matrix, scratchScale);
return Cartesian3.maximumComponent(scratchScale);
};
/**
* Computes the product of two matrices.
*
* @param {Matrix3} left The first matrix.
* @param {Matrix3} right The second matrix.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*/
Matrix3.multiply = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
var column0Row0 = left[0] * right[0] + left[3] * right[1] + left[6] * right[2];
var column0Row1 = left[1] * right[0] + left[4] * right[1] + left[7] * right[2];
var column0Row2 = left[2] * right[0] + left[5] * right[1] + left[8] * right[2];
var column1Row0 = left[0] * right[3] + left[3] * right[4] + left[6] * right[5];
var column1Row1 = left[1] * right[3] + left[4] * right[4] + left[7] * right[5];
var column1Row2 = left[2] * right[3] + left[5] * right[4] + left[8] * right[5];
var column2Row0 = left[0] * right[6] + left[3] * right[7] + left[6] * right[8];
var column2Row1 = left[1] * right[6] + left[4] * right[7] + left[7] * right[8];
var column2Row2 = left[2] * right[6] + left[5] * right[7] + left[8] * right[8];
result[0] = column0Row0;
result[1] = column0Row1;
result[2] = column0Row2;
result[3] = column1Row0;
result[4] = column1Row1;
result[5] = column1Row2;
result[6] = column2Row0;
result[7] = column2Row1;
result[8] = column2Row2;
return result;
};
/**
* Computes the sum of two matrices.
*
* @param {Matrix3} left The first matrix.
* @param {Matrix3} right The second matrix.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*/
Matrix3.add = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result[0] = left[0] + right[0];
result[1] = left[1] + right[1];
result[2] = left[2] + right[2];
result[3] = left[3] + right[3];
result[4] = left[4] + right[4];
result[5] = left[5] + right[5];
result[6] = left[6] + right[6];
result[7] = left[7] + right[7];
result[8] = left[8] + right[8];
return result;
};
/**
* Computes the difference of two matrices.
*
* @param {Matrix3} left The first matrix.
* @param {Matrix3} right The second matrix.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*/
Matrix3.subtract = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result[0] = left[0] - right[0];
result[1] = left[1] - right[1];
result[2] = left[2] - right[2];
result[3] = left[3] - right[3];
result[4] = left[4] - right[4];
result[5] = left[5] - right[5];
result[6] = left[6] - right[6];
result[7] = left[7] - right[7];
result[8] = left[8] - right[8];
return result;
};
/**
* Computes the product of a matrix and a column vector.
*
* @param {Matrix3} matrix The matrix.
* @param {Cartesian3} cartesian The column.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Matrix3.multiplyByVector = function(matrix, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var vX = cartesian.x;
var vY = cartesian.y;
var vZ = cartesian.z;
var x = matrix[0] * vX + matrix[3] * vY + matrix[6] * vZ;
var y = matrix[1] * vX + matrix[4] * vY + matrix[7] * vZ;
var z = matrix[2] * vX + matrix[5] * vY + matrix[8] * vZ;
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Computes the product of a matrix and a scalar.
*
* @param {Matrix3} matrix The matrix.
* @param {Number} scalar The number to multiply by.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*/
Matrix3.multiplyByScalar = function(matrix, scalar, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number('scalar', scalar);
Check.typeOf.object('result', result);
result[0] = matrix[0] * scalar;
result[1] = matrix[1] * scalar;
result[2] = matrix[2] * scalar;
result[3] = matrix[3] * scalar;
result[4] = matrix[4] * scalar;
result[5] = matrix[5] * scalar;
result[6] = matrix[6] * scalar;
result[7] = matrix[7] * scalar;
result[8] = matrix[8] * scalar;
return result;
};
/**
* Computes the product of a matrix times a (non-uniform) scale, as if the scale were a scale matrix.
*
* @param {Matrix3} matrix The matrix on the left-hand side.
* @param {Cartesian3} scale The non-uniform scale on the right-hand side.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*
*
* @example
* // Instead of Cesium.Matrix3.multiply(m, Cesium.Matrix3.fromScale(scale), m);
* Cesium.Matrix3.multiplyByScale(m, scale, m);
*
* @see Matrix3.fromScale
* @see Matrix3.multiplyByUniformScale
*/
Matrix3.multiplyByScale = function(matrix, scale, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('scale', scale);
Check.typeOf.object('result', result);
result[0] = matrix[0] * scale.x;
result[1] = matrix[1] * scale.x;
result[2] = matrix[2] * scale.x;
result[3] = matrix[3] * scale.y;
result[4] = matrix[4] * scale.y;
result[5] = matrix[5] * scale.y;
result[6] = matrix[6] * scale.z;
result[7] = matrix[7] * scale.z;
result[8] = matrix[8] * scale.z;
return result;
};
/**
* Creates a negated copy of the provided matrix.
*
* @param {Matrix3} matrix The matrix to negate.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*/
Matrix3.negate = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result[0] = -matrix[0];
result[1] = -matrix[1];
result[2] = -matrix[2];
result[3] = -matrix[3];
result[4] = -matrix[4];
result[5] = -matrix[5];
result[6] = -matrix[6];
result[7] = -matrix[7];
result[8] = -matrix[8];
return result;
};
/**
* Computes the transpose of the provided matrix.
*
* @param {Matrix3} matrix The matrix to transpose.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*/
Matrix3.transpose = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
var column0Row0 = matrix[0];
var column0Row1 = matrix[3];
var column0Row2 = matrix[6];
var column1Row0 = matrix[1];
var column1Row1 = matrix[4];
var column1Row2 = matrix[7];
var column2Row0 = matrix[2];
var column2Row1 = matrix[5];
var column2Row2 = matrix[8];
result[0] = column0Row0;
result[1] = column0Row1;
result[2] = column0Row2;
result[3] = column1Row0;
result[4] = column1Row1;
result[5] = column1Row2;
result[6] = column2Row0;
result[7] = column2Row1;
result[8] = column2Row2;
return result;
};
function computeFrobeniusNorm(matrix) {
var norm = 0.0;
for (var i = 0; i < 9; ++i) {
var temp = matrix[i];
norm += temp * temp;
}
return Math.sqrt(norm);
}
var rowVal = [1, 0, 0];
var colVal = [2, 2, 1];
function offDiagonalFrobeniusNorm(matrix) {
// Computes the "off-diagonal" Frobenius norm.
// Assumes matrix is symmetric.
var norm = 0.0;
for (var i = 0; i < 3; ++i) {
var temp = matrix[Matrix3.getElementIndex(colVal[i], rowVal[i])];
norm += 2.0 * temp * temp;
}
return Math.sqrt(norm);
}
function shurDecomposition(matrix, result) {
// This routine was created based upon Matrix Computations, 3rd ed., by Golub and Van Loan,
// section 8.4.2 The 2by2 Symmetric Schur Decomposition.
//
// The routine takes a matrix, which is assumed to be symmetric, and
// finds the largest off-diagonal term, and then creates
// a matrix (result) which can be used to help reduce it
var tolerance = CesiumMath.EPSILON15;
var maxDiagonal = 0.0;
var rotAxis = 1;
// find pivot (rotAxis) based on max diagonal of matrix
for (var i = 0; i < 3; ++i) {
var temp = Math.abs(matrix[Matrix3.getElementIndex(colVal[i], rowVal[i])]);
if (temp > maxDiagonal) {
rotAxis = i;
maxDiagonal = temp;
}
}
var c = 1.0;
var s = 0.0;
var p = rowVal[rotAxis];
var q = colVal[rotAxis];
if (Math.abs(matrix[Matrix3.getElementIndex(q, p)]) > tolerance) {
var qq = matrix[Matrix3.getElementIndex(q, q)];
var pp = matrix[Matrix3.getElementIndex(p, p)];
var qp = matrix[Matrix3.getElementIndex(q, p)];
var tau = (qq - pp) / 2.0 / qp;
var t;
if (tau < 0.0) {
t = -1.0 / (-tau + Math.sqrt(1.0 + tau * tau));
} else {
t = 1.0 / (tau + Math.sqrt(1.0 + tau * tau));
}
c = 1.0 / Math.sqrt(1.0 + t * t);
s = t * c;
}
result = Matrix3.clone(Matrix3.IDENTITY, result);
result[Matrix3.getElementIndex(p, p)] = result[Matrix3.getElementIndex(q, q)] = c;
result[Matrix3.getElementIndex(q, p)] = s;
result[Matrix3.getElementIndex(p, q)] = -s;
return result;
}
var jMatrix = new Matrix3();
var jMatrixTranspose = new Matrix3();
/**
* Computes the eigenvectors and eigenvalues of a symmetric matrix.
* <p>
* Returns a diagonal matrix and unitary matrix such that:
* <code>matrix = unitary matrix * diagonal matrix * transpose(unitary matrix)</code>
* </p>
* <p>
* The values along the diagonal of the diagonal matrix are the eigenvalues. The columns
* of the unitary matrix are the corresponding eigenvectors.
* </p>
*
* @param {Matrix3} matrix The matrix to decompose into diagonal and unitary matrix. Expected to be symmetric.
* @param {Object} [result] An object with unitary and diagonal properties which are matrices onto which to store the result.
* @returns {Object} An object with unitary and diagonal properties which are the unitary and diagonal matrices, respectively.
*
* @example
* var a = //... symetric matrix
* var result = {
* unitary : new Cesium.Matrix3(),
* diagonal : new Cesium.Matrix3()
* };
* Cesium.Matrix3.computeEigenDecomposition(a, result);
*
* var unitaryTranspose = Cesium.Matrix3.transpose(result.unitary, new Cesium.Matrix3());
* var b = Cesium.Matrix3.multiply(result.unitary, result.diagonal, new Cesium.Matrix3());
* Cesium.Matrix3.multiply(b, unitaryTranspose, b); // b is now equal to a
*
* var lambda = Cesium.Matrix3.getColumn(result.diagonal, 0, new Cesium.Cartesian3()).x; // first eigenvalue
* var v = Cesium.Matrix3.getColumn(result.unitary, 0, new Cesium.Cartesian3()); // first eigenvector
* var c = Cesium.Cartesian3.multiplyByScalar(v, lambda, new Cesium.Cartesian3()); // equal to Cesium.Matrix3.multiplyByVector(a, v)
*/
Matrix3.computeEigenDecomposition = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
// This routine was created based upon Matrix Computations, 3rd ed., by Golub and Van Loan,
// section 8.4.3 The Classical Jacobi Algorithm
var tolerance = CesiumMath.EPSILON20;
var maxSweeps = 10;
var count = 0;
var sweep = 0;
if (!defined(result)) {
result = {};
}
var unitaryMatrix = result.unitary = Matrix3.clone(Matrix3.IDENTITY, result.unitary);
var diagMatrix = result.diagonal = Matrix3.clone(matrix, result.diagonal);
var epsilon = tolerance * computeFrobeniusNorm(diagMatrix);
while (sweep < maxSweeps && offDiagonalFrobeniusNorm(diagMatrix) > epsilon) {
shurDecomposition(diagMatrix, jMatrix);
Matrix3.transpose(jMatrix, jMatrixTranspose);
Matrix3.multiply(diagMatrix, jMatrix, diagMatrix);
Matrix3.multiply(jMatrixTranspose, diagMatrix, diagMatrix);
Matrix3.multiply(unitaryMatrix, jMatrix, unitaryMatrix);
if (++count > 2) {
++sweep;
count = 0;
}
}
return result;
};
/**
* Computes a matrix, which contains the absolute (unsigned) values of the provided matrix's elements.
*
* @param {Matrix3} matrix The matrix with signed elements.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*/
Matrix3.abs = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result[0] = Math.abs(matrix[0]);
result[1] = Math.abs(matrix[1]);
result[2] = Math.abs(matrix[2]);
result[3] = Math.abs(matrix[3]);
result[4] = Math.abs(matrix[4]);
result[5] = Math.abs(matrix[5]);
result[6] = Math.abs(matrix[6]);
result[7] = Math.abs(matrix[7]);
result[8] = Math.abs(matrix[8]);
return result;
};
/**
* Computes the determinant of the provided matrix.
*
* @param {Matrix3} matrix The matrix to use.
* @returns {Number} The value of the determinant of the matrix.
*/
Matrix3.determinant = function(matrix) {
Check.typeOf.object('matrix', matrix);
var m11 = matrix[0];
var m21 = matrix[3];
var m31 = matrix[6];
var m12 = matrix[1];
var m22 = matrix[4];
var m32 = matrix[7];
var m13 = matrix[2];
var m23 = matrix[5];
var m33 = matrix[8];
return m11 * (m22 * m33 - m23 * m32) + m12 * (m23 * m31 - m21 * m33) + m13 * (m21 * m32 - m22 * m31);
};
/**
* Computes the inverse of the provided matrix.
*
* @param {Matrix3} matrix The matrix to invert.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*
* @exception {DeveloperError} matrix is not invertible.
*/
Matrix3.inverse = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
var m11 = matrix[0];
var m21 = matrix[1];
var m31 = matrix[2];
var m12 = matrix[3];
var m22 = matrix[4];
var m32 = matrix[5];
var m13 = matrix[6];
var m23 = matrix[7];
var m33 = matrix[8];
var determinant = Matrix3.determinant(matrix);
if (Math.abs(determinant) <= CesiumMath.EPSILON15) {
throw new DeveloperError('matrix is not invertible');
}
result[0] = m22 * m33 - m23 * m32;
result[1] = m23 * m31 - m21 * m33;
result[2] = m21 * m32 - m22 * m31;
result[3] = m13 * m32 - m12 * m33;
result[4] = m11 * m33 - m13 * m31;
result[5] = m12 * m31 - m11 * m32;
result[6] = m12 * m23 - m13 * m22;
result[7] = m13 * m21 - m11 * m23;
result[8] = m11 * m22 - m12 * m21;
var scale = 1.0 / determinant;
return Matrix3.multiplyByScalar(result, scale, result);
};
/**
* Compares the provided matrices componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Matrix3} [left] The first matrix.
* @param {Matrix3} [right] The second matrix.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
Matrix3.equals = function(left, right) {
return (left === right) ||
(defined(left) &&
defined(right) &&
left[0] === right[0] &&
left[1] === right[1] &&
left[2] === right[2] &&
left[3] === right[3] &&
left[4] === right[4] &&
left[5] === right[5] &&
left[6] === right[6] &&
left[7] === right[7] &&
left[8] === right[8]);
};
/**
* Compares the provided matrices componentwise and returns
* <code>true</code> if they are within the provided epsilon,
* <code>false</code> otherwise.
*
* @param {Matrix3} [left] The first matrix.
* @param {Matrix3} [right] The second matrix.
* @param {Number} epsilon The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
*/
Matrix3.equalsEpsilon = function(left, right, epsilon) {
Check.typeOf.number('epsilon', epsilon);
return (left === right) ||
(defined(left) &&
defined(right) &&
Math.abs(left[0] - right[0]) <= epsilon &&
Math.abs(left[1] - right[1]) <= epsilon &&
Math.abs(left[2] - right[2]) <= epsilon &&
Math.abs(left[3] - right[3]) <= epsilon &&
Math.abs(left[4] - right[4]) <= epsilon &&
Math.abs(left[5] - right[5]) <= epsilon &&
Math.abs(left[6] - right[6]) <= epsilon &&
Math.abs(left[7] - right[7]) <= epsilon &&
Math.abs(left[8] - right[8]) <= epsilon);
};
/**
* An immutable Matrix3 instance initialized to the identity matrix.
*
* @type {Matrix3}
* @constant
*/
Matrix3.IDENTITY = freezeObject(new Matrix3(1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0));
/**
* An immutable Matrix3 instance initialized to the zero matrix.
*
* @type {Matrix3}
* @constant
*/
Matrix3.ZERO = freezeObject(new Matrix3(0.0, 0.0, 0.0,
0.0, 0.0, 0.0,
0.0, 0.0, 0.0));
/**
* The index into Matrix3 for column 0, row 0.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN0ROW0 = 0;
/**
* The index into Matrix3 for column 0, row 1.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN0ROW1 = 1;
/**
* The index into Matrix3 for column 0, row 2.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN0ROW2 = 2;
/**
* The index into Matrix3 for column 1, row 0.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN1ROW0 = 3;
/**
* The index into Matrix3 for column 1, row 1.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN1ROW1 = 4;
/**
* The index into Matrix3 for column 1, row 2.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN1ROW2 = 5;
/**
* The index into Matrix3 for column 2, row 0.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN2ROW0 = 6;
/**
* The index into Matrix3 for column 2, row 1.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN2ROW1 = 7;
/**
* The index into Matrix3 for column 2, row 2.
*
* @type {Number}
* @constant
*/
Matrix3.COLUMN2ROW2 = 8;
defineProperties(Matrix3.prototype, {
/**
* Gets the number of items in the collection.
* @memberof Matrix3.prototype
*
* @type {Number}
*/
length : {
get : function() {
return Matrix3.packedLength;
}
}
});
/**
* Duplicates the provided Matrix3 instance.
*
* @param {Matrix3} [result] The object onto which to store the result.
* @returns {Matrix3} The modified result parameter or a new Matrix3 instance if one was not provided.
*/
Matrix3.prototype.clone = function(result) {
return Matrix3.clone(this, result);
};
/**
* Compares this matrix to the provided matrix componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Matrix3} [right] The right hand side matrix.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
Matrix3.prototype.equals = function(right) {
return Matrix3.equals(this, right);
};
/**
* @private
*/
Matrix3.equalsArray = function(matrix, array, offset) {
return matrix[0] === array[offset] &&
matrix[1] === array[offset + 1] &&
matrix[2] === array[offset + 2] &&
matrix[3] === array[offset + 3] &&
matrix[4] === array[offset + 4] &&
matrix[5] === array[offset + 5] &&
matrix[6] === array[offset + 6] &&
matrix[7] === array[offset + 7] &&
matrix[8] === array[offset + 8];
};
/**
* Compares this matrix to the provided matrix componentwise and returns
* <code>true</code> if they are within the provided epsilon,
* <code>false</code> otherwise.
*
* @param {Matrix3} [right] The right hand side matrix.
* @param {Number} epsilon The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
*/
Matrix3.prototype.equalsEpsilon = function(right, epsilon) {
return Matrix3.equalsEpsilon(this, right, epsilon);
};
/**
* Creates a string representing this Matrix with each row being
* on a separate line and in the format '(column0, column1, column2)'.
*
* @returns {String} A string representing the provided Matrix with each row being on a separate line and in the format '(column0, column1, column2)'.
*/
Matrix3.prototype.toString = function() {
return '(' + this[0] + ', ' + this[3] + ', ' + this[6] + ')\n' +
'(' + this[1] + ', ' + this[4] + ', ' + this[7] + ')\n' +
'(' + this[2] + ', ' + this[5] + ', ' + this[8] + ')';
};
return Matrix3;
});
/*global define*/
define('Core/Cartesian4',[
'./Check',
'./defaultValue',
'./defined',
'./DeveloperError',
'./freezeObject',
'./Math'
], function(
Check,
defaultValue,
defined,
DeveloperError,
freezeObject,
CesiumMath) {
'use strict';
/**
* A 4D Cartesian point.
* @alias Cartesian4
* @constructor
*
* @param {Number} [x=0.0] The X component.
* @param {Number} [y=0.0] The Y component.
* @param {Number} [z=0.0] The Z component.
* @param {Number} [w=0.0] The W component.
*
* @see Cartesian2
* @see Cartesian3
* @see Packable
*/
function Cartesian4(x, y, z, w) {
/**
* The X component.
* @type {Number}
* @default 0.0
*/
this.x = defaultValue(x, 0.0);
/**
* The Y component.
* @type {Number}
* @default 0.0
*/
this.y = defaultValue(y, 0.0);
/**
* The Z component.
* @type {Number}
* @default 0.0
*/
this.z = defaultValue(z, 0.0);
/**
* The W component.
* @type {Number}
* @default 0.0
*/
this.w = defaultValue(w, 0.0);
}
/**
* Creates a Cartesian4 instance from x, y, z and w coordinates.
*
* @param {Number} x The x coordinate.
* @param {Number} y The y coordinate.
* @param {Number} z The z coordinate.
* @param {Number} w The w coordinate.
* @param {Cartesian4} [result] The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
*/
Cartesian4.fromElements = function(x, y, z, w, result) {
if (!defined(result)) {
return new Cartesian4(x, y, z, w);
}
result.x = x;
result.y = y;
result.z = z;
result.w = w;
return result;
};
/**
* Creates a Cartesian4 instance from a {@link Color}. <code>red</code>, <code>green</code>, <code>blue</code>,
* and <code>alpha</code> map to <code>x</code>, <code>y</code>, <code>z</code>, and <code>w</code>, respectively.
*
* @param {Color} color The source color.
* @param {Cartesian4} [result] The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
*/
Cartesian4.fromColor = function(color, result) {
Check.typeOf.object('color', color);
if (!defined(result)) {
return new Cartesian4(color.red, color.green, color.blue, color.alpha);
}
result.x = color.red;
result.y = color.green;
result.z = color.blue;
result.w = color.alpha;
return result;
};
/**
* Duplicates a Cartesian4 instance.
*
* @param {Cartesian4} cartesian The Cartesian to duplicate.
* @param {Cartesian4} [result] The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided. (Returns undefined if cartesian is undefined)
*/
Cartesian4.clone = function(cartesian, result) {
if (!defined(cartesian)) {
return undefined;
}
if (!defined(result)) {
return new Cartesian4(cartesian.x, cartesian.y, cartesian.z, cartesian.w);
}
result.x = cartesian.x;
result.y = cartesian.y;
result.z = cartesian.z;
result.w = cartesian.w;
return result;
};
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Cartesian4.packedLength = 4;
/**
* Stores the provided instance into the provided array.
*
* @param {Cartesian4} 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
*/
Cartesian4.pack = function(value, array, startingIndex) {
Check.typeOf.object('value', value);
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value.x;
array[startingIndex++] = value.y;
array[startingIndex++] = value.z;
array[startingIndex] = value.w;
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 {Cartesian4} [result] The object into which to store the result.
* @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
*/
Cartesian4.unpack = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Cartesian4();
}
result.x = array[startingIndex++];
result.y = array[startingIndex++];
result.z = array[startingIndex++];
result.w = array[startingIndex];
return result;
};
/**
* Flattens an array of Cartesian4s into and array of components.
*
* @param {Cartesian4[]} array The array of cartesians to pack.
* @param {Number[]} result The array onto which to store the result.
* @returns {Number[]} The packed array.
*/
Cartesian4.packArray = function(array, result) {
Check.defined('array', array);
var length = array.length;
if (!defined(result)) {
result = new Array(length * 4);
} else {
result.length = length * 4;
}
for (var i = 0; i < length; ++i) {
Cartesian4.pack(array[i], result, i * 4);
}
return result;
};
/**
* Unpacks an array of cartesian components into and array of Cartesian4s.
*
* @param {Number[]} array The array of components to unpack.
* @param {Cartesian4[]} result The array onto which to store the result.
* @returns {Cartesian4[]} The unpacked array.
*/
Cartesian4.unpackArray = function(array, result) {
Check.defined('array', array);
var length = array.length;
if (!defined(result)) {
result = new Array(length / 4);
} else {
result.length = length / 4;
}
for (var i = 0; i < length; i += 4) {
var index = i / 4;
result[index] = Cartesian4.unpack(array, i, result[index]);
}
return result;
};
/**
* Creates a Cartesian4 from four consecutive elements in an array.
* @function
*
* @param {Number[]} array The array whose four consecutive elements correspond to the x, y, z, and w components, respectively.
* @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to the x component.
* @param {Cartesian4} [result] The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
*
* @example
* // Create a Cartesian4 with (1.0, 2.0, 3.0, 4.0)
* var v = [1.0, 2.0, 3.0, 4.0];
* var p = Cesium.Cartesian4.fromArray(v);
*
* // Create a Cartesian4 with (1.0, 2.0, 3.0, 4.0) using an offset into an array
* var v2 = [0.0, 0.0, 1.0, 2.0, 3.0, 4.0];
* var p2 = Cesium.Cartesian4.fromArray(v2, 2);
*/
Cartesian4.fromArray = Cartesian4.unpack;
/**
* Computes the value of the maximum component for the supplied Cartesian.
*
* @param {Cartesian4} cartesian The cartesian to use.
* @returns {Number} The value of the maximum component.
*/
Cartesian4.maximumComponent = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return Math.max(cartesian.x, cartesian.y, cartesian.z, cartesian.w);
};
/**
* Computes the value of the minimum component for the supplied Cartesian.
*
* @param {Cartesian4} cartesian The cartesian to use.
* @returns {Number} The value of the minimum component.
*/
Cartesian4.minimumComponent = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return Math.min(cartesian.x, cartesian.y, cartesian.z, cartesian.w);
};
/**
* Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
*
* @param {Cartesian4} first A cartesian to compare.
* @param {Cartesian4} second A cartesian to compare.
* @param {Cartesian4} result The object into which to store the result.
* @returns {Cartesian4} A cartesian with the minimum components.
*/
Cartesian4.minimumByComponent = function(first, second, result) {
Check.typeOf.object('first', first);
Check.typeOf.object('second', second);
Check.typeOf.object('result', result);
result.x = Math.min(first.x, second.x);
result.y = Math.min(first.y, second.y);
result.z = Math.min(first.z, second.z);
result.w = Math.min(first.w, second.w);
return result;
};
/**
* Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
*
* @param {Cartesian4} first A cartesian to compare.
* @param {Cartesian4} second A cartesian to compare.
* @param {Cartesian4} result The object into which to store the result.
* @returns {Cartesian4} A cartesian with the maximum components.
*/
Cartesian4.maximumByComponent = function(first, second, result) {
Check.typeOf.object('first', first);
Check.typeOf.object('second', second);
Check.typeOf.object('result', result);
result.x = Math.max(first.x, second.x);
result.y = Math.max(first.y, second.y);
result.z = Math.max(first.z, second.z);
result.w = Math.max(first.w, second.w);
return result;
};
/**
* Computes the provided Cartesian's squared magnitude.
*
* @param {Cartesian4} cartesian The Cartesian instance whose squared magnitude is to be computed.
* @returns {Number} The squared magnitude.
*/
Cartesian4.magnitudeSquared = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return cartesian.x * cartesian.x + cartesian.y * cartesian.y + cartesian.z * cartesian.z + cartesian.w * cartesian.w;
};
/**
* Computes the Cartesian's magnitude (length).
*
* @param {Cartesian4} cartesian The Cartesian instance whose magnitude is to be computed.
* @returns {Number} The magnitude.
*/
Cartesian4.magnitude = function(cartesian) {
return Math.sqrt(Cartesian4.magnitudeSquared(cartesian));
};
var distanceScratch = new Cartesian4();
/**
* Computes the 4-space distance between two points.
*
* @param {Cartesian4} left The first point to compute the distance from.
* @param {Cartesian4} right The second point to compute the distance to.
* @returns {Number} The distance between two points.
*
* @example
* // Returns 1.0
* var d = Cesium.Cartesian4.distance(
* new Cesium.Cartesian4(1.0, 0.0, 0.0, 0.0),
* new Cesium.Cartesian4(2.0, 0.0, 0.0, 0.0));
*/
Cartesian4.distance = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Cartesian4.subtract(left, right, distanceScratch);
return Cartesian4.magnitude(distanceScratch);
};
/**
* Computes the squared distance between two points. Comparing squared distances
* using this function is more efficient than comparing distances using {@link Cartesian4#distance}.
*
* @param {Cartesian4} left The first point to compute the distance from.
* @param {Cartesian4} right The second point to compute the distance to.
* @returns {Number} The distance between two points.
*
* @example
* // Returns 4.0, not 2.0
* var d = Cesium.Cartesian4.distance(
* new Cesium.Cartesian4(1.0, 0.0, 0.0, 0.0),
* new Cesium.Cartesian4(3.0, 0.0, 0.0, 0.0));
*/
Cartesian4.distanceSquared = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Cartesian4.subtract(left, right, distanceScratch);
return Cartesian4.magnitudeSquared(distanceScratch);
};
/**
* Computes the normalized form of the supplied Cartesian.
*
* @param {Cartesian4} cartesian The Cartesian to be normalized.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.normalize = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var magnitude = Cartesian4.magnitude(cartesian);
result.x = cartesian.x / magnitude;
result.y = cartesian.y / magnitude;
result.z = cartesian.z / magnitude;
result.w = cartesian.w / magnitude;
if (isNaN(result.x) || isNaN(result.y) || isNaN(result.z) || isNaN(result.w)) {
throw new DeveloperError('normalized result is not a number');
}
return result;
};
/**
* Computes the dot (scalar) product of two Cartesians.
*
* @param {Cartesian4} left The first Cartesian.
* @param {Cartesian4} right The second Cartesian.
* @returns {Number} The dot product.
*/
Cartesian4.dot = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
return left.x * right.x + left.y * right.y + left.z * right.z + left.w * right.w;
};
/**
* Computes the componentwise product of two Cartesians.
*
* @param {Cartesian4} left The first Cartesian.
* @param {Cartesian4} right The second Cartesian.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.multiplyComponents = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result.x = left.x * right.x;
result.y = left.y * right.y;
result.z = left.z * right.z;
result.w = left.w * right.w;
return result;
};
/**
* Computes the componentwise quotient of two Cartesians.
*
* @param {Cartesian4} left The first Cartesian.
* @param {Cartesian4} right The second Cartesian.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.divideComponents = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result.x = left.x / right.x;
result.y = left.y / right.y;
result.z = left.z / right.z;
result.w = left.w / right.w;
return result;
};
/**
* Computes the componentwise sum of two Cartesians.
*
* @param {Cartesian4} left The first Cartesian.
* @param {Cartesian4} right The second Cartesian.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.add = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result.x = left.x + right.x;
result.y = left.y + right.y;
result.z = left.z + right.z;
result.w = left.w + right.w;
return result;
};
/**
* Computes the componentwise difference of two Cartesians.
*
* @param {Cartesian4} left The first Cartesian.
* @param {Cartesian4} right The second Cartesian.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.subtract = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result.x = left.x - right.x;
result.y = left.y - right.y;
result.z = left.z - right.z;
result.w = left.w - right.w;
return result;
};
/**
* Multiplies the provided Cartesian componentwise by the provided scalar.
*
* @param {Cartesian4} cartesian The Cartesian to be scaled.
* @param {Number} scalar The scalar to multiply with.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.multiplyByScalar = function(cartesian, scalar, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.number('scalar', scalar);
Check.typeOf.object('result', result);
result.x = cartesian.x * scalar;
result.y = cartesian.y * scalar;
result.z = cartesian.z * scalar;
result.w = cartesian.w * scalar;
return result;
};
/**
* Divides the provided Cartesian componentwise by the provided scalar.
*
* @param {Cartesian4} cartesian The Cartesian to be divided.
* @param {Number} scalar The scalar to divide by.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.divideByScalar = function(cartesian, scalar, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.number('scalar', scalar);
Check.typeOf.object('result', result);
result.x = cartesian.x / scalar;
result.y = cartesian.y / scalar;
result.z = cartesian.z / scalar;
result.w = cartesian.w / scalar;
return result;
};
/**
* Negates the provided Cartesian.
*
* @param {Cartesian4} cartesian The Cartesian to be negated.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.negate = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result.x = -cartesian.x;
result.y = -cartesian.y;
result.z = -cartesian.z;
result.w = -cartesian.w;
return result;
};
/**
* Computes the absolute value of the provided Cartesian.
*
* @param {Cartesian4} cartesian The Cartesian whose absolute value is to be computed.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.abs = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result.x = Math.abs(cartesian.x);
result.y = Math.abs(cartesian.y);
result.z = Math.abs(cartesian.z);
result.w = Math.abs(cartesian.w);
return result;
};
var lerpScratch = new Cartesian4();
/**
* Computes the linear interpolation or extrapolation at t using the provided cartesians.
*
* @param {Cartesian4} start The value corresponding to t at 0.0.
* @param {Cartesian4}end The value corresponding to t at 1.0.
* @param {Number} t The point along t at which to interpolate.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Cartesian4.lerp = function(start, end, t, result) {
Check.typeOf.object('start', start);
Check.typeOf.object('end', end);
Check.typeOf.number('t', t);
Check.typeOf.object('result', result);
Cartesian4.multiplyByScalar(end, t, lerpScratch);
result = Cartesian4.multiplyByScalar(start, 1.0 - t, result);
return Cartesian4.add(lerpScratch, result, result);
};
var mostOrthogonalAxisScratch = new Cartesian4();
/**
* Returns the axis that is most orthogonal to the provided Cartesian.
*
* @param {Cartesian4} cartesian The Cartesian on which to find the most orthogonal axis.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The most orthogonal axis.
*/
Cartesian4.mostOrthogonalAxis = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var f = Cartesian4.normalize(cartesian, mostOrthogonalAxisScratch);
Cartesian4.abs(f, f);
if (f.x <= f.y) {
if (f.x <= f.z) {
if (f.x <= f.w) {
result = Cartesian4.clone(Cartesian4.UNIT_X, result);
} else {
result = Cartesian4.clone(Cartesian4.UNIT_W, result);
}
} else if (f.z <= f.w) {
result = Cartesian4.clone(Cartesian4.UNIT_Z, result);
} else {
result = Cartesian4.clone(Cartesian4.UNIT_W, result);
}
} else if (f.y <= f.z) {
if (f.y <= f.w) {
result = Cartesian4.clone(Cartesian4.UNIT_Y, result);
} else {
result = Cartesian4.clone(Cartesian4.UNIT_W, result);
}
} else if (f.z <= f.w) {
result = Cartesian4.clone(Cartesian4.UNIT_Z, result);
} else {
result = Cartesian4.clone(Cartesian4.UNIT_W, result);
}
return result;
};
/**
* Compares the provided Cartesians componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Cartesian4} [left] The first Cartesian.
* @param {Cartesian4} [right] The second Cartesian.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
Cartesian4.equals = function(left, right) {
return (left === right) ||
((defined(left)) &&
(defined(right)) &&
(left.x === right.x) &&
(left.y === right.y) &&
(left.z === right.z) &&
(left.w === right.w));
};
/**
* @private
*/
Cartesian4.equalsArray = function(cartesian, array, offset) {
return cartesian.x === array[offset] &&
cartesian.y === array[offset + 1] &&
cartesian.z === array[offset + 2] &&
cartesian.w === array[offset + 3];
};
/**
* Compares the provided Cartesians componentwise and returns
* <code>true</code> if they pass an absolute or relative tolerance test,
* <code>false</code> otherwise.
*
* @param {Cartesian4} [left] The first Cartesian.
* @param {Cartesian4} [right] The second Cartesian.
* @param {Number} relativeEpsilon The relative epsilon tolerance to use for equality testing.
* @param {Number} [absoluteEpsilon=relativeEpsilon] The absolute epsilon tolerance to use for equality testing.
* @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
*/
Cartesian4.equalsEpsilon = function(left, right, relativeEpsilon, absoluteEpsilon) {
return (left === right) ||
(defined(left) &&
defined(right) &&
CesiumMath.equalsEpsilon(left.x, right.x, relativeEpsilon, absoluteEpsilon) &&
CesiumMath.equalsEpsilon(left.y, right.y, relativeEpsilon, absoluteEpsilon) &&
CesiumMath.equalsEpsilon(left.z, right.z, relativeEpsilon, absoluteEpsilon) &&
CesiumMath.equalsEpsilon(left.w, right.w, relativeEpsilon, absoluteEpsilon));
};
/**
* An immutable Cartesian4 instance initialized to (0.0, 0.0, 0.0, 0.0).
*
* @type {Cartesian4}
* @constant
*/
Cartesian4.ZERO = freezeObject(new Cartesian4(0.0, 0.0, 0.0, 0.0));
/**
* An immutable Cartesian4 instance initialized to (1.0, 0.0, 0.0, 0.0).
*
* @type {Cartesian4}
* @constant
*/
Cartesian4.UNIT_X = freezeObject(new Cartesian4(1.0, 0.0, 0.0, 0.0));
/**
* An immutable Cartesian4 instance initialized to (0.0, 1.0, 0.0, 0.0).
*
* @type {Cartesian4}
* @constant
*/
Cartesian4.UNIT_Y = freezeObject(new Cartesian4(0.0, 1.0, 0.0, 0.0));
/**
* An immutable Cartesian4 instance initialized to (0.0, 0.0, 1.0, 0.0).
*
* @type {Cartesian4}
* @constant
*/
Cartesian4.UNIT_Z = freezeObject(new Cartesian4(0.0, 0.0, 1.0, 0.0));
/**
* An immutable Cartesian4 instance initialized to (0.0, 0.0, 0.0, 1.0).
*
* @type {Cartesian4}
* @constant
*/
Cartesian4.UNIT_W = freezeObject(new Cartesian4(0.0, 0.0, 0.0, 1.0));
/**
* Duplicates this Cartesian4 instance.
*
* @param {Cartesian4} [result] The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter or a new Cartesian4 instance if one was not provided.
*/
Cartesian4.prototype.clone = function(result) {
return Cartesian4.clone(this, result);
};
/**
* Compares this Cartesian against the provided Cartesian componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Cartesian4} [right] The right hand side Cartesian.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
Cartesian4.prototype.equals = function(right) {
return Cartesian4.equals(this, right);
};
/**
* Compares this Cartesian against the provided Cartesian componentwise and returns
* <code>true</code> if they pass an absolute or relative tolerance test,
* <code>false</code> otherwise.
*
* @param {Cartesian4} [right] The right hand side Cartesian.
* @param {Number} relativeEpsilon The relative epsilon tolerance to use for equality testing.
* @param {Number} [absoluteEpsilon=relativeEpsilon] The absolute epsilon tolerance to use for equality testing.
* @returns {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
*/
Cartesian4.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
return Cartesian4.equalsEpsilon(this, right, relativeEpsilon, absoluteEpsilon);
};
/**
* Creates a string representing this Cartesian in the format '(x, y)'.
*
* @returns {String} A string representing the provided Cartesian in the format '(x, y)'.
*/
Cartesian4.prototype.toString = function() {
return '(' + this.x + ', ' + this.y + ', ' + this.z + ', ' + this.w + ')';
};
return Cartesian4;
});
/*global define*/
define('Core/RuntimeError',[
'./defined'
], function(
defined) {
'use strict';
/**
* Constructs an exception object that is thrown due to an error that can occur at runtime, e.g.,
* out of memory, could not compile shader, etc. If a function may throw this
* exception, the calling code should be prepared to catch it.
* <br /><br />
* On the other hand, a {@link DeveloperError} indicates an exception due
* to a developer error, e.g., invalid argument, that usually indicates a bug in the
* calling code.
*
* @alias RuntimeError
* @constructor
* @extends Error
*
* @param {String} [message] The error message for this exception.
*
* @see DeveloperError
*/
function RuntimeError(message) {
/**
* 'RuntimeError' indicating that this exception was thrown due to a runtime error.
* @type {String}
* @readonly
*/
this.name = 'RuntimeError';
/**
* The explanation for why this exception was thrown.
* @type {String}
* @readonly
*/
this.message = message;
//Browsers such as IE don't have a stack property until you actually throw the error.
var stack;
try {
throw new Error();
} catch (e) {
stack = e.stack;
}
/**
* The stack trace of this exception, if available.
* @type {String}
* @readonly
*/
this.stack = stack;
}
if (defined(Object.create)) {
RuntimeError.prototype = Object.create(Error.prototype);
RuntimeError.prototype.constructor = RuntimeError;
}
RuntimeError.prototype.toString = function() {
var str = this.name + ': ' + this.message;
if (defined(this.stack)) {
str += '\n' + this.stack.toString();
}
return str;
};
return RuntimeError;
});
/*global define*/
define('Core/Matrix4',[
'./Cartesian3',
'./Cartesian4',
'./Check',
'./defaultValue',
'./defined',
'./defineProperties',
'./freezeObject',
'./Math',
'./Matrix3',
'./RuntimeError'
], function(
Cartesian3,
Cartesian4,
Check,
defaultValue,
defined,
defineProperties,
freezeObject,
CesiumMath,
Matrix3,
RuntimeError) {
'use strict';
/**
* A 4x4 matrix, indexable as a column-major order array.
* Constructor parameters are in row-major order for code readability.
* @alias Matrix4
* @constructor
*
* @param {Number} [column0Row0=0.0] The value for column 0, row 0.
* @param {Number} [column1Row0=0.0] The value for column 1, row 0.
* @param {Number} [column2Row0=0.0] The value for column 2, row 0.
* @param {Number} [column3Row0=0.0] The value for column 3, row 0.
* @param {Number} [column0Row1=0.0] The value for column 0, row 1.
* @param {Number} [column1Row1=0.0] The value for column 1, row 1.
* @param {Number} [column2Row1=0.0] The value for column 2, row 1.
* @param {Number} [column3Row1=0.0] The value for column 3, row 1.
* @param {Number} [column0Row2=0.0] The value for column 0, row 2.
* @param {Number} [column1Row2=0.0] The value for column 1, row 2.
* @param {Number} [column2Row2=0.0] The value for column 2, row 2.
* @param {Number} [column3Row2=0.0] The value for column 3, row 2.
* @param {Number} [column0Row3=0.0] The value for column 0, row 3.
* @param {Number} [column1Row3=0.0] The value for column 1, row 3.
* @param {Number} [column2Row3=0.0] The value for column 2, row 3.
* @param {Number} [column3Row3=0.0] The value for column 3, row 3.
*
* @see Matrix4.fromColumnMajorArray
* @see Matrix4.fromRowMajorArray
* @see Matrix4.fromRotationTranslation
* @see Matrix4.fromTranslationRotationScale
* @see Matrix4.fromTranslationQuaternionRotationScale
* @see Matrix4.fromTranslation
* @see Matrix4.fromScale
* @see Matrix4.fromUniformScale
* @see Matrix4.fromCamera
* @see Matrix4.computePerspectiveFieldOfView
* @see Matrix4.computeOrthographicOffCenter
* @see Matrix4.computePerspectiveOffCenter
* @see Matrix4.computeInfinitePerspectiveOffCenter
* @see Matrix4.computeViewportTransformation
* @see Matrix4.computeView
* @see Matrix2
* @see Matrix3
* @see Packable
*/
function Matrix4(column0Row0, column1Row0, column2Row0, column3Row0,
column0Row1, column1Row1, column2Row1, column3Row1,
column0Row2, column1Row2, column2Row2, column3Row2,
column0Row3, column1Row3, column2Row3, column3Row3) {
this[0] = defaultValue(column0Row0, 0.0);
this[1] = defaultValue(column0Row1, 0.0);
this[2] = defaultValue(column0Row2, 0.0);
this[3] = defaultValue(column0Row3, 0.0);
this[4] = defaultValue(column1Row0, 0.0);
this[5] = defaultValue(column1Row1, 0.0);
this[6] = defaultValue(column1Row2, 0.0);
this[7] = defaultValue(column1Row3, 0.0);
this[8] = defaultValue(column2Row0, 0.0);
this[9] = defaultValue(column2Row1, 0.0);
this[10] = defaultValue(column2Row2, 0.0);
this[11] = defaultValue(column2Row3, 0.0);
this[12] = defaultValue(column3Row0, 0.0);
this[13] = defaultValue(column3Row1, 0.0);
this[14] = defaultValue(column3Row2, 0.0);
this[15] = defaultValue(column3Row3, 0.0);
}
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Matrix4.packedLength = 16;
/**
* Stores the provided instance into the provided array.
*
* @param {Matrix4} 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
*/
Matrix4.pack = function(value, array, startingIndex) {
Check.typeOf.object('value', value);
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value[0];
array[startingIndex++] = value[1];
array[startingIndex++] = value[2];
array[startingIndex++] = value[3];
array[startingIndex++] = value[4];
array[startingIndex++] = value[5];
array[startingIndex++] = value[6];
array[startingIndex++] = value[7];
array[startingIndex++] = value[8];
array[startingIndex++] = value[9];
array[startingIndex++] = value[10];
array[startingIndex++] = value[11];
array[startingIndex++] = value[12];
array[startingIndex++] = value[13];
array[startingIndex++] = value[14];
array[startingIndex] = value[15];
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 {Matrix4} [result] The object into which to store the result.
* @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
*/
Matrix4.unpack = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Matrix4();
}
result[0] = array[startingIndex++];
result[1] = array[startingIndex++];
result[2] = array[startingIndex++];
result[3] = array[startingIndex++];
result[4] = array[startingIndex++];
result[5] = array[startingIndex++];
result[6] = array[startingIndex++];
result[7] = array[startingIndex++];
result[8] = array[startingIndex++];
result[9] = array[startingIndex++];
result[10] = array[startingIndex++];
result[11] = array[startingIndex++];
result[12] = array[startingIndex++];
result[13] = array[startingIndex++];
result[14] = array[startingIndex++];
result[15] = array[startingIndex];
return result;
};
/**
* Duplicates a Matrix4 instance.
*
* @param {Matrix4} matrix The matrix to duplicate.
* @param {Matrix4} [result] The object onto which to store the result.
* @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided. (Returns undefined if matrix is undefined)
*/
Matrix4.clone = function(matrix, result) {
if (!defined(matrix)) {
return undefined;
}
if (!defined(result)) {
return new Matrix4(matrix[0], matrix[4], matrix[8], matrix[12],
matrix[1], matrix[5], matrix[9], matrix[13],
matrix[2], matrix[6], matrix[10], matrix[14],
matrix[3], matrix[7], matrix[11], matrix[15]);
}
result[0] = matrix[0];
result[1] = matrix[1];
result[2] = matrix[2];
result[3] = matrix[3];
result[4] = matrix[4];
result[5] = matrix[5];
result[6] = matrix[6];
result[7] = matrix[7];
result[8] = matrix[8];
result[9] = matrix[9];
result[10] = matrix[10];
result[11] = matrix[11];
result[12] = matrix[12];
result[13] = matrix[13];
result[14] = matrix[14];
result[15] = matrix[15];
return result;
};
/**
* Creates a Matrix4 from 16 consecutive elements in an array.
* @function
*
* @param {Number[]} array The array whose 16 consecutive elements correspond to the positions of the matrix. Assumes column-major order.
* @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to first column first row position in the matrix.
* @param {Matrix4} [result] The object onto which to store the result.
* @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
*
* @example
* // Create the Matrix4:
* // [1.0, 2.0, 3.0, 4.0]
* // [1.0, 2.0, 3.0, 4.0]
* // [1.0, 2.0, 3.0, 4.0]
* // [1.0, 2.0, 3.0, 4.0]
*
* var v = [1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0];
* var m = Cesium.Matrix4.fromArray(v);
*
* // Create same Matrix4 with using an offset into an array
* var v2 = [0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0, 3.0, 4.0, 4.0, 4.0, 4.0];
* var m2 = Cesium.Matrix4.fromArray(v2, 2);
*/
Matrix4.fromArray = Matrix4.unpack;
/**
* Computes a Matrix4 instance from a column-major order array.
*
* @param {Number[]} values The column-major order array.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*/
Matrix4.fromColumnMajorArray = function(values, result) {
Check.defined('values', values);
return Matrix4.clone(values, result);
};
/**
* Computes a Matrix4 instance from a row-major order array.
* The resulting matrix will be in column-major order.
*
* @param {Number[]} values The row-major order array.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*/
Matrix4.fromRowMajorArray = function(values, result) {
Check.defined('values', values);
if (!defined(result)) {
return new Matrix4(values[0], values[1], values[2], values[3],
values[4], values[5], values[6], values[7],
values[8], values[9], values[10], values[11],
values[12], values[13], values[14], values[15]);
}
result[0] = values[0];
result[1] = values[4];
result[2] = values[8];
result[3] = values[12];
result[4] = values[1];
result[5] = values[5];
result[6] = values[9];
result[7] = values[13];
result[8] = values[2];
result[9] = values[6];
result[10] = values[10];
result[11] = values[14];
result[12] = values[3];
result[13] = values[7];
result[14] = values[11];
result[15] = values[15];
return result;
};
/**
* Computes a Matrix4 instance from a Matrix3 representing the rotation
* and a Cartesian3 representing the translation.
*
* @param {Matrix3} rotation The upper left portion of the matrix representing the rotation.
* @param {Cartesian3} [translation=Cartesian3.ZERO] The upper right portion of the matrix representing the translation.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*/
Matrix4.fromRotationTranslation = function(rotation, translation, result) {
Check.typeOf.object('rotation', rotation);
translation = defaultValue(translation, Cartesian3.ZERO);
if (!defined(result)) {
return new Matrix4(rotation[0], rotation[3], rotation[6], translation.x,
rotation[1], rotation[4], rotation[7], translation.y,
rotation[2], rotation[5], rotation[8], translation.z,
0.0, 0.0, 0.0, 1.0);
}
result[0] = rotation[0];
result[1] = rotation[1];
result[2] = rotation[2];
result[3] = 0.0;
result[4] = rotation[3];
result[5] = rotation[4];
result[6] = rotation[5];
result[7] = 0.0;
result[8] = rotation[6];
result[9] = rotation[7];
result[10] = rotation[8];
result[11] = 0.0;
result[12] = translation.x;
result[13] = translation.y;
result[14] = translation.z;
result[15] = 1.0;
return result;
};
/**
* Computes a Matrix4 instance from a translation, rotation, and scale (TRS)
* representation with the rotation represented as a quaternion.
*
* @param {Cartesian3} translation The translation transformation.
* @param {Quaternion} rotation The rotation transformation.
* @param {Cartesian3} scale The non-uniform scale transformation.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*
* @example
* var result = Cesium.Matrix4.fromTranslationQuaternionRotationScale(
* new Cesium.Cartesian3(1.0, 2.0, 3.0), // translation
* Cesium.Quaternion.IDENTITY, // rotation
* new Cesium.Cartesian3(7.0, 8.0, 9.0), // scale
* result);
*/
Matrix4.fromTranslationQuaternionRotationScale = function(translation, rotation, scale, result) {
Check.typeOf.object('translation', translation);
Check.typeOf.object('rotation', rotation);
Check.typeOf.object('scale', scale);
if (!defined(result)) {
result = new Matrix4();
}
var scaleX = scale.x;
var scaleY = scale.y;
var scaleZ = scale.z;
var x2 = rotation.x * rotation.x;
var xy = rotation.x * rotation.y;
var xz = rotation.x * rotation.z;
var xw = rotation.x * rotation.w;
var y2 = rotation.y * rotation.y;
var yz = rotation.y * rotation.z;
var yw = rotation.y * rotation.w;
var z2 = rotation.z * rotation.z;
var zw = rotation.z * rotation.w;
var w2 = rotation.w * rotation.w;
var m00 = x2 - y2 - z2 + w2;
var m01 = 2.0 * (xy - zw);
var m02 = 2.0 * (xz + yw);
var m10 = 2.0 * (xy + zw);
var m11 = -x2 + y2 - z2 + w2;
var m12 = 2.0 * (yz - xw);
var m20 = 2.0 * (xz - yw);
var m21 = 2.0 * (yz + xw);
var m22 = -x2 - y2 + z2 + w2;
result[0] = m00 * scaleX;
result[1] = m10 * scaleX;
result[2] = m20 * scaleX;
result[3] = 0.0;
result[4] = m01 * scaleY;
result[5] = m11 * scaleY;
result[6] = m21 * scaleY;
result[7] = 0.0;
result[8] = m02 * scaleZ;
result[9] = m12 * scaleZ;
result[10] = m22 * scaleZ;
result[11] = 0.0;
result[12] = translation.x;
result[13] = translation.y;
result[14] = translation.z;
result[15] = 1.0;
return result;
};
/**
* Creates a Matrix4 instance from a {@link TranslationRotationScale} instance.
*
* @param {TranslationRotationScale} translationRotationScale The instance.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*/
Matrix4.fromTranslationRotationScale = function(translationRotationScale, result) {
Check.typeOf.object('translationRotationScale', translationRotationScale);
return Matrix4.fromTranslationQuaternionRotationScale(translationRotationScale.translation, translationRotationScale.rotation, translationRotationScale.scale, result);
};
/**
* Creates a Matrix4 instance from a Cartesian3 representing the translation.
*
* @param {Cartesian3} translation The upper right portion of the matrix representing the translation.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*
* @see Matrix4.multiplyByTranslation
*/
Matrix4.fromTranslation = function(translation, result) {
Check.typeOf.object('translation', translation);
return Matrix4.fromRotationTranslation(Matrix3.IDENTITY, translation, result);
};
/**
* Computes a Matrix4 instance representing a non-uniform scale.
*
* @param {Cartesian3} scale The x, y, and z scale factors.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*
* @example
* // Creates
* // [7.0, 0.0, 0.0, 0.0]
* // [0.0, 8.0, 0.0, 0.0]
* // [0.0, 0.0, 9.0, 0.0]
* // [0.0, 0.0, 0.0, 1.0]
* var m = Cesium.Matrix4.fromScale(new Cesium.Cartesian3(7.0, 8.0, 9.0));
*/
Matrix4.fromScale = function(scale, result) {
Check.typeOf.object('scale', scale);
if (!defined(result)) {
return new Matrix4(
scale.x, 0.0, 0.0, 0.0,
0.0, scale.y, 0.0, 0.0,
0.0, 0.0, scale.z, 0.0,
0.0, 0.0, 0.0, 1.0);
}
result[0] = scale.x;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = scale.y;
result[6] = 0.0;
result[7] = 0.0;
result[8] = 0.0;
result[9] = 0.0;
result[10] = scale.z;
result[11] = 0.0;
result[12] = 0.0;
result[13] = 0.0;
result[14] = 0.0;
result[15] = 1.0;
return result;
};
/**
* Computes a Matrix4 instance representing a uniform scale.
*
* @param {Number} scale The uniform scale factor.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*
* @example
* // Creates
* // [2.0, 0.0, 0.0, 0.0]
* // [0.0, 2.0, 0.0, 0.0]
* // [0.0, 0.0, 2.0, 0.0]
* // [0.0, 0.0, 0.0, 1.0]
* var m = Cesium.Matrix4.fromUniformScale(2.0);
*/
Matrix4.fromUniformScale = function(scale, result) {
Check.typeOf.number('scale', scale);
if (!defined(result)) {
return new Matrix4(scale, 0.0, 0.0, 0.0,
0.0, scale, 0.0, 0.0,
0.0, 0.0, scale, 0.0,
0.0, 0.0, 0.0, 1.0);
}
result[0] = scale;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = scale;
result[6] = 0.0;
result[7] = 0.0;
result[8] = 0.0;
result[9] = 0.0;
result[10] = scale;
result[11] = 0.0;
result[12] = 0.0;
result[13] = 0.0;
result[14] = 0.0;
result[15] = 1.0;
return result;
};
var fromCameraF = new Cartesian3();
var fromCameraR = new Cartesian3();
var fromCameraU = new Cartesian3();
/**
* Computes a Matrix4 instance from a Camera.
*
* @param {Camera} camera The camera to use.
* @param {Matrix4} [result] The object in which the result will be stored, if undefined a new instance will be created.
* @returns {Matrix4} The modified result parameter, or a new Matrix4 instance if one was not provided.
*/
Matrix4.fromCamera = function(camera, result) {
Check.typeOf.object('camera', camera);
var position = camera.position;
var direction = camera.direction;
var up = camera.up;
Check.typeOf.object('camera.position', position);
Check.typeOf.object('camera.direction', direction);
Check.typeOf.object('camera.up', up);
Cartesian3.normalize(direction, fromCameraF);
Cartesian3.normalize(Cartesian3.cross(fromCameraF, up, fromCameraR), fromCameraR);
Cartesian3.normalize(Cartesian3.cross(fromCameraR, fromCameraF, fromCameraU), fromCameraU);
var sX = fromCameraR.x;
var sY = fromCameraR.y;
var sZ = fromCameraR.z;
var fX = fromCameraF.x;
var fY = fromCameraF.y;
var fZ = fromCameraF.z;
var uX = fromCameraU.x;
var uY = fromCameraU.y;
var uZ = fromCameraU.z;
var positionX = position.x;
var positionY = position.y;
var positionZ = position.z;
var t0 = sX * -positionX + sY * -positionY+ sZ * -positionZ;
var t1 = uX * -positionX + uY * -positionY+ uZ * -positionZ;
var t2 = fX * positionX + fY * positionY + fZ * positionZ;
// The code below this comment is an optimized
// version of the commented lines.
// Rather that create two matrices and then multiply,
// we just bake in the multiplcation as part of creation.
// var rotation = new Matrix4(
// sX, sY, sZ, 0.0,
// uX, uY, uZ, 0.0,
// -fX, -fY, -fZ, 0.0,
// 0.0, 0.0, 0.0, 1.0);
// var translation = new Matrix4(
// 1.0, 0.0, 0.0, -position.x,
// 0.0, 1.0, 0.0, -position.y,
// 0.0, 0.0, 1.0, -position.z,
// 0.0, 0.0, 0.0, 1.0);
// return rotation.multiply(translation);
if (!defined(result)) {
return new Matrix4(
sX, sY, sZ, t0,
uX, uY, uZ, t1,
-fX, -fY, -fZ, t2,
0.0, 0.0, 0.0, 1.0);
}
result[0] = sX;
result[1] = uX;
result[2] = -fX;
result[3] = 0.0;
result[4] = sY;
result[5] = uY;
result[6] = -fY;
result[7] = 0.0;
result[8] = sZ;
result[9] = uZ;
result[10] = -fZ;
result[11] = 0.0;
result[12] = t0;
result[13] = t1;
result[14] = t2;
result[15] = 1.0;
return result;
};
/**
* Computes a Matrix4 instance representing a perspective transformation matrix.
*
* @param {Number} fovY The field of view along the Y axis in radians.
* @param {Number} aspectRatio The aspect ratio.
* @param {Number} near The distance to the near plane in meters.
* @param {Number} far The distance to the far plane in meters.
* @param {Matrix4} result The object in which the result will be stored.
* @returns {Matrix4} The modified result parameter.
*
* @exception {DeveloperError} fovY must be in (0, PI].
* @exception {DeveloperError} aspectRatio must be greater than zero.
* @exception {DeveloperError} near must be greater than zero.
* @exception {DeveloperError} far must be greater than zero.
*/
Matrix4.computePerspectiveFieldOfView = function(fovY, aspectRatio, near, far, result) {
Check.typeOf.number.greaterThan('fovY', fovY, 0.0);
Check.typeOf.number.lessThan('fovY', fovY, Math.PI);
Check.typeOf.number.greaterThan('near', near, 0.0);
Check.typeOf.number.greaterThan('far', far, 0.0);
Check.typeOf.object('result', result);
var bottom = Math.tan(fovY * 0.5);
var column1Row1 = 1.0 / bottom;
var column0Row0 = column1Row1 / aspectRatio;
var column2Row2 = (far + near) / (near - far);
var column3Row2 = (2.0 * far * near) / (near - far);
result[0] = column0Row0;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = column1Row1;
result[6] = 0.0;
result[7] = 0.0;
result[8] = 0.0;
result[9] = 0.0;
result[10] = column2Row2;
result[11] = -1.0;
result[12] = 0.0;
result[13] = 0.0;
result[14] = column3Row2;
result[15] = 0.0;
return result;
};
/**
* Computes a Matrix4 instance representing an orthographic transformation matrix.
*
* @param {Number} left The number of meters to the left of the camera that will be in view.
* @param {Number} right The number of meters to the right of the camera that will be in view.
* @param {Number} bottom The number of meters below of the camera that will be in view.
* @param {Number} top The number of meters above of the camera that will be in view.
* @param {Number} near The distance to the near plane in meters.
* @param {Number} far The distance to the far plane in meters.
* @param {Matrix4} result The object in which the result will be stored.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.computeOrthographicOffCenter = function(left, right, bottom, top, near, far, result) {
Check.typeOf.number('left', left);
Check.typeOf.number('right', right);
Check.typeOf.number('bottom', bottom);
Check.typeOf.number('top', top);
Check.typeOf.number('near', near);
Check.typeOf.number('far', far);
Check.typeOf.object('result', result);
var a = 1.0 / (right - left);
var b = 1.0 / (top - bottom);
var c = 1.0 / (far - near);
var tx = -(right + left) * a;
var ty = -(top + bottom) * b;
var tz = -(far + near) * c;
a *= 2.0;
b *= 2.0;
c *= -2.0;
result[0] = a;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = b;
result[6] = 0.0;
result[7] = 0.0;
result[8] = 0.0;
result[9] = 0.0;
result[10] = c;
result[11] = 0.0;
result[12] = tx;
result[13] = ty;
result[14] = tz;
result[15] = 1.0;
return result;
};
/**
* Computes a Matrix4 instance representing an off center perspective transformation.
*
* @param {Number} left The number of meters to the left of the camera that will be in view.
* @param {Number} right The number of meters to the right of the camera that will be in view.
* @param {Number} bottom The number of meters below of the camera that will be in view.
* @param {Number} top The number of meters above of the camera that will be in view.
* @param {Number} near The distance to the near plane in meters.
* @param {Number} far The distance to the far plane in meters.
* @param {Matrix4} result The object in which the result will be stored.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.computePerspectiveOffCenter = function(left, right, bottom, top, near, far, result) {
Check.typeOf.number('left', left);
Check.typeOf.number('right', right);
Check.typeOf.number('bottom', bottom);
Check.typeOf.number('top', top);
Check.typeOf.number('near', near);
Check.typeOf.number('far', far);
Check.typeOf.object('result', result);
var column0Row0 = 2.0 * near / (right - left);
var column1Row1 = 2.0 * near / (top - bottom);
var column2Row0 = (right + left) / (right - left);
var column2Row1 = (top + bottom) / (top - bottom);
var column2Row2 = -(far + near) / (far - near);
var column2Row3 = -1.0;
var column3Row2 = -2.0 * far * near / (far - near);
result[0] = column0Row0;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = column1Row1;
result[6] = 0.0;
result[7] = 0.0;
result[8] = column2Row0;
result[9] = column2Row1;
result[10] = column2Row2;
result[11] = column2Row3;
result[12] = 0.0;
result[13] = 0.0;
result[14] = column3Row2;
result[15] = 0.0;
return result;
};
/**
* Computes a Matrix4 instance representing an infinite off center perspective transformation.
*
* @param {Number} left The number of meters to the left of the camera that will be in view.
* @param {Number} right The number of meters to the right of the camera that will be in view.
* @param {Number} bottom The number of meters below of the camera that will be in view.
* @param {Number} top The number of meters above of the camera that will be in view.
* @param {Number} near The distance to the near plane in meters.
* @param {Matrix4} result The object in which the result will be stored.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.computeInfinitePerspectiveOffCenter = function(left, right, bottom, top, near, result) {
Check.typeOf.number('left', left);
Check.typeOf.number('right', right);
Check.typeOf.number('bottom', bottom);
Check.typeOf.number('top', top);
Check.typeOf.number('near', near);
Check.typeOf.object('result', result);
var column0Row0 = 2.0 * near / (right - left);
var column1Row1 = 2.0 * near / (top - bottom);
var column2Row0 = (right + left) / (right - left);
var column2Row1 = (top + bottom) / (top - bottom);
var column2Row2 = -1.0;
var column2Row3 = -1.0;
var column3Row2 = -2.0 * near;
result[0] = column0Row0;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = column1Row1;
result[6] = 0.0;
result[7] = 0.0;
result[8] = column2Row0;
result[9] = column2Row1;
result[10] = column2Row2;
result[11] = column2Row3;
result[12] = 0.0;
result[13] = 0.0;
result[14] = column3Row2;
result[15] = 0.0;
return result;
};
/**
* Computes a Matrix4 instance that transforms from normalized device coordinates to window coordinates.
*
* @param {Object}[viewport = { x : 0.0, y : 0.0, width : 0.0, height : 0.0 }] The viewport's corners as shown in Example 1.
* @param {Number}[nearDepthRange=0.0] The near plane distance in window coordinates.
* @param {Number}[farDepthRange=1.0] The far plane distance in window coordinates.
* @param {Matrix4} result The object in which the result will be stored.
* @returns {Matrix4} The modified result parameter.
*
* @example
* // Create viewport transformation using an explicit viewport and depth range.
* var m = Cesium.Matrix4.computeViewportTransformation({
* x : 0.0,
* y : 0.0,
* width : 1024.0,
* height : 768.0
* }, 0.0, 1.0, new Cesium.Matrix4());
*/
Matrix4.computeViewportTransformation = function(viewport, nearDepthRange, farDepthRange, result) {
Check.typeOf.object('result', result);
viewport = defaultValue(viewport, defaultValue.EMPTY_OBJECT);
var x = defaultValue(viewport.x, 0.0);
var y = defaultValue(viewport.y, 0.0);
var width = defaultValue(viewport.width, 0.0);
var height = defaultValue(viewport.height, 0.0);
nearDepthRange = defaultValue(nearDepthRange, 0.0);
farDepthRange = defaultValue(farDepthRange, 1.0);
var halfWidth = width * 0.5;
var halfHeight = height * 0.5;
var halfDepth = (farDepthRange - nearDepthRange) * 0.5;
var column0Row0 = halfWidth;
var column1Row1 = halfHeight;
var column2Row2 = halfDepth;
var column3Row0 = x + halfWidth;
var column3Row1 = y + halfHeight;
var column3Row2 = nearDepthRange + halfDepth;
var column3Row3 = 1.0;
result[0] = column0Row0;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = column1Row1;
result[6] = 0.0;
result[7] = 0.0;
result[8] = 0.0;
result[9] = 0.0;
result[10] = column2Row2;
result[11] = 0.0;
result[12] = column3Row0;
result[13] = column3Row1;
result[14] = column3Row2;
result[15] = column3Row3;
return result;
};
/**
* Computes a Matrix4 instance that transforms from world space to view space.
*
* @param {Cartesian3} position The position of the camera.
* @param {Cartesian3} direction The forward direction.
* @param {Cartesian3} up The up direction.
* @param {Cartesian3} right The right direction.
* @param {Matrix4} result The object in which the result will be stored.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.computeView = function(position, direction, up, right, result) {
Check.typeOf.object('position', position);
Check.typeOf.object('direction', direction);
Check.typeOf.object('up', up);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result[0] = right.x;
result[1] = up.x;
result[2] = -direction.x;
result[3] = 0.0;
result[4] = right.y;
result[5] = up.y;
result[6] = -direction.y;
result[7] = 0.0;
result[8] = right.z;
result[9] = up.z;
result[10] = -direction.z;
result[11] = 0.0;
result[12] = -Cartesian3.dot(right, position);
result[13] = -Cartesian3.dot(up, position);
result[14] = Cartesian3.dot(direction, position);
result[15] = 1.0;
return result;
};
/**
* Computes an Array from the provided Matrix4 instance.
* The array will be in column-major order.
*
* @param {Matrix4} matrix The matrix to use..
* @param {Number[]} [result] The Array onto which to store the result.
* @returns {Number[]} The modified Array parameter or a new Array instance if one was not provided.
*
* @example
* //create an array from an instance of Matrix4
* // m = [10.0, 14.0, 18.0, 22.0]
* // [11.0, 15.0, 19.0, 23.0]
* // [12.0, 16.0, 20.0, 24.0]
* // [13.0, 17.0, 21.0, 25.0]
* var a = Cesium.Matrix4.toArray(m);
*
* // m remains the same
* //creates a = [10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0, 25.0]
*/
Matrix4.toArray = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
if (!defined(result)) {
return [matrix[0], matrix[1], matrix[2], matrix[3],
matrix[4], matrix[5], matrix[6], matrix[7],
matrix[8], matrix[9], matrix[10], matrix[11],
matrix[12], matrix[13], matrix[14], matrix[15]];
}
result[0] = matrix[0];
result[1] = matrix[1];
result[2] = matrix[2];
result[3] = matrix[3];
result[4] = matrix[4];
result[5] = matrix[5];
result[6] = matrix[6];
result[7] = matrix[7];
result[8] = matrix[8];
result[9] = matrix[9];
result[10] = matrix[10];
result[11] = matrix[11];
result[12] = matrix[12];
result[13] = matrix[13];
result[14] = matrix[14];
result[15] = matrix[15];
return result;
};
/**
* Computes the array index of the element at the provided row and column.
*
* @param {Number} row The zero-based index of the row.
* @param {Number} column The zero-based index of the column.
* @returns {Number} The index of the element at the provided row and column.
*
* @exception {DeveloperError} row must be 0, 1, 2, or 3.
* @exception {DeveloperError} column must be 0, 1, 2, or 3.
*
* @example
* var myMatrix = new Cesium.Matrix4();
* var column1Row0Index = Cesium.Matrix4.getElementIndex(1, 0);
* var column1Row0 = myMatrix[column1Row0Index];
* myMatrix[column1Row0Index] = 10.0;
*/
Matrix4.getElementIndex = function(column, row) {
Check.typeOf.number.greaterThanOrEquals('row', row, 0);
Check.typeOf.number.lessThanOrEquals('row', row, 3);
Check.typeOf.number.greaterThanOrEquals('column', column, 0);
Check.typeOf.number.lessThanOrEquals('column', column, 3);
return column * 4 + row;
};
/**
* Retrieves a copy of the matrix column at the provided index as a Cartesian4 instance.
*
* @param {Matrix4} matrix The matrix to use.
* @param {Number} index The zero-based index of the column to retrieve.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, 2, or 3.
*
* @example
* //returns a Cartesian4 instance with values from the specified column
* // m = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [18.0, 19.0, 20.0, 21.0]
* // [22.0, 23.0, 24.0, 25.0]
*
* //Example 1: Creates an instance of Cartesian
* var a = Cesium.Matrix4.getColumn(m, 2, new Cesium.Cartesian4());
*
* @example
* //Example 2: Sets values for Cartesian instance
* var a = new Cesium.Cartesian4();
* Cesium.Matrix4.getColumn(m, 2, a);
*
* // a.x = 12.0; a.y = 16.0; a.z = 20.0; a.w = 24.0;
*/
Matrix4.getColumn = function(matrix, index, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 3);
Check.typeOf.object('result', result);
var startIndex = index * 4;
var x = matrix[startIndex];
var y = matrix[startIndex + 1];
var z = matrix[startIndex + 2];
var w = matrix[startIndex + 3];
result.x = x;
result.y = y;
result.z = z;
result.w = w;
return result;
};
/**
* Computes a new matrix that replaces the specified column in the provided matrix with the provided Cartesian4 instance.
*
* @param {Matrix4} matrix The matrix to use.
* @param {Number} index The zero-based index of the column to set.
* @param {Cartesian4} cartesian The Cartesian whose values will be assigned to the specified column.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, 2, or 3.
*
* @example
* //creates a new Matrix4 instance with new column values from the Cartesian4 instance
* // m = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [18.0, 19.0, 20.0, 21.0]
* // [22.0, 23.0, 24.0, 25.0]
*
* var a = Cesium.Matrix4.setColumn(m, 2, new Cesium.Cartesian4(99.0, 98.0, 97.0, 96.0), new Cesium.Matrix4());
*
* // m remains the same
* // a = [10.0, 11.0, 99.0, 13.0]
* // [14.0, 15.0, 98.0, 17.0]
* // [18.0, 19.0, 97.0, 21.0]
* // [22.0, 23.0, 96.0, 25.0]
*/
Matrix4.setColumn = function(matrix, index, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 3);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result = Matrix4.clone(matrix, result);
var startIndex = index * 4;
result[startIndex] = cartesian.x;
result[startIndex + 1] = cartesian.y;
result[startIndex + 2] = cartesian.z;
result[startIndex + 3] = cartesian.w;
return result;
};
/**
* Computes a new matrix that replaces the translation in the rightmost column of the provided
* matrix with the provided translation. This assumes the matrix is an affine transformation
*
* @param {Matrix4} matrix The matrix to use.
* @param {Cartesian3} translation The translation that replaces the translation of the provided matrix.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.setTranslation = function(matrix, translation, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('translation', translation);
Check.typeOf.object('result', result);
result[0] = matrix[0];
result[1] = matrix[1];
result[2] = matrix[2];
result[3] = matrix[3];
result[4] = matrix[4];
result[5] = matrix[5];
result[6] = matrix[6];
result[7] = matrix[7];
result[8] = matrix[8];
result[9] = matrix[9];
result[10] = matrix[10];
result[11] = matrix[11];
result[12] = translation.x;
result[13] = translation.y;
result[14] = translation.z;
result[15] = matrix[15];
return result;
};
/**
* Retrieves a copy of the matrix row at the provided index as a Cartesian4 instance.
*
* @param {Matrix4} matrix The matrix to use.
* @param {Number} index The zero-based index of the row to retrieve.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, 2, or 3.
*
* @example
* //returns a Cartesian4 instance with values from the specified column
* // m = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [18.0, 19.0, 20.0, 21.0]
* // [22.0, 23.0, 24.0, 25.0]
*
* //Example 1: Returns an instance of Cartesian
* var a = Cesium.Matrix4.getRow(m, 2, new Cesium.Cartesian4());
*
* @example
* //Example 2: Sets values for a Cartesian instance
* var a = new Cesium.Cartesian4();
* Cesium.Matrix4.getRow(m, 2, a);
*
* // a.x = 18.0; a.y = 19.0; a.z = 20.0; a.w = 21.0;
*/
Matrix4.getRow = function(matrix, index, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 3);
Check.typeOf.object('result', result);
var x = matrix[index];
var y = matrix[index + 4];
var z = matrix[index + 8];
var w = matrix[index + 12];
result.x = x;
result.y = y;
result.z = z;
result.w = w;
return result;
};
/**
* Computes a new matrix that replaces the specified row in the provided matrix with the provided Cartesian4 instance.
*
* @param {Matrix4} matrix The matrix to use.
* @param {Number} index The zero-based index of the row to set.
* @param {Cartesian4} cartesian The Cartesian whose values will be assigned to the specified row.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @exception {DeveloperError} index must be 0, 1, 2, or 3.
*
* @example
* //create a new Matrix4 instance with new row values from the Cartesian4 instance
* // m = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [18.0, 19.0, 20.0, 21.0]
* // [22.0, 23.0, 24.0, 25.0]
*
* var a = Cesium.Matrix4.setRow(m, 2, new Cesium.Cartesian4(99.0, 98.0, 97.0, 96.0), new Cesium.Matrix4());
*
* // m remains the same
* // a = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [99.0, 98.0, 97.0, 96.0]
* // [22.0, 23.0, 24.0, 25.0]
*/
Matrix4.setRow = function(matrix, index, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number.greaterThanOrEquals('index', index, 0);
Check.typeOf.number.lessThanOrEquals('index', index, 3);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result = Matrix4.clone(matrix, result);
result[index] = cartesian.x;
result[index + 4] = cartesian.y;
result[index + 8] = cartesian.z;
result[index + 12] = cartesian.w;
return result;
};
var scratchColumn = new Cartesian3();
/**
* Extracts the non-uniform scale assuming the matrix is an affine transformation.
*
* @param {Matrix4} matrix The matrix.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter
*/
Matrix4.getScale = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result.x = Cartesian3.magnitude(Cartesian3.fromElements(matrix[0], matrix[1], matrix[2], scratchColumn));
result.y = Cartesian3.magnitude(Cartesian3.fromElements(matrix[4], matrix[5], matrix[6], scratchColumn));
result.z = Cartesian3.magnitude(Cartesian3.fromElements(matrix[8], matrix[9], matrix[10], scratchColumn));
return result;
};
var scratchScale = new Cartesian3();
/**
* Computes the maximum scale assuming the matrix is an affine transformation.
* The maximum scale is the maximum length of the column vectors in the upper-left
* 3x3 matrix.
*
* @param {Matrix4} matrix The matrix.
* @returns {Number} The maximum scale.
*/
Matrix4.getMaximumScale = function(matrix) {
Matrix4.getScale(matrix, scratchScale);
return Cartesian3.maximumComponent(scratchScale);
};
/**
* Computes the product of two matrices.
*
* @param {Matrix4} left The first matrix.
* @param {Matrix4} right The second matrix.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.multiply = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
var left0 = left[0];
var left1 = left[1];
var left2 = left[2];
var left3 = left[3];
var left4 = left[4];
var left5 = left[5];
var left6 = left[6];
var left7 = left[7];
var left8 = left[8];
var left9 = left[9];
var left10 = left[10];
var left11 = left[11];
var left12 = left[12];
var left13 = left[13];
var left14 = left[14];
var left15 = left[15];
var right0 = right[0];
var right1 = right[1];
var right2 = right[2];
var right3 = right[3];
var right4 = right[4];
var right5 = right[5];
var right6 = right[6];
var right7 = right[7];
var right8 = right[8];
var right9 = right[9];
var right10 = right[10];
var right11 = right[11];
var right12 = right[12];
var right13 = right[13];
var right14 = right[14];
var right15 = right[15];
var column0Row0 = left0 * right0 + left4 * right1 + left8 * right2 + left12 * right3;
var column0Row1 = left1 * right0 + left5 * right1 + left9 * right2 + left13 * right3;
var column0Row2 = left2 * right0 + left6 * right1 + left10 * right2 + left14 * right3;
var column0Row3 = left3 * right0 + left7 * right1 + left11 * right2 + left15 * right3;
var column1Row0 = left0 * right4 + left4 * right5 + left8 * right6 + left12 * right7;
var column1Row1 = left1 * right4 + left5 * right5 + left9 * right6 + left13 * right7;
var column1Row2 = left2 * right4 + left6 * right5 + left10 * right6 + left14 * right7;
var column1Row3 = left3 * right4 + left7 * right5 + left11 * right6 + left15 * right7;
var column2Row0 = left0 * right8 + left4 * right9 + left8 * right10 + left12 * right11;
var column2Row1 = left1 * right8 + left5 * right9 + left9 * right10 + left13 * right11;
var column2Row2 = left2 * right8 + left6 * right9 + left10 * right10 + left14 * right11;
var column2Row3 = left3 * right8 + left7 * right9 + left11 * right10 + left15 * right11;
var column3Row0 = left0 * right12 + left4 * right13 + left8 * right14 + left12 * right15;
var column3Row1 = left1 * right12 + left5 * right13 + left9 * right14 + left13 * right15;
var column3Row2 = left2 * right12 + left6 * right13 + left10 * right14 + left14 * right15;
var column3Row3 = left3 * right12 + left7 * right13 + left11 * right14 + left15 * right15;
result[0] = column0Row0;
result[1] = column0Row1;
result[2] = column0Row2;
result[3] = column0Row3;
result[4] = column1Row0;
result[5] = column1Row1;
result[6] = column1Row2;
result[7] = column1Row3;
result[8] = column2Row0;
result[9] = column2Row1;
result[10] = column2Row2;
result[11] = column2Row3;
result[12] = column3Row0;
result[13] = column3Row1;
result[14] = column3Row2;
result[15] = column3Row3;
return result;
};
/**
* Computes the sum of two matrices.
*
* @param {Matrix4} left The first matrix.
* @param {Matrix4} right The second matrix.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.add = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result[0] = left[0] + right[0];
result[1] = left[1] + right[1];
result[2] = left[2] + right[2];
result[3] = left[3] + right[3];
result[4] = left[4] + right[4];
result[5] = left[5] + right[5];
result[6] = left[6] + right[6];
result[7] = left[7] + right[7];
result[8] = left[8] + right[8];
result[9] = left[9] + right[9];
result[10] = left[10] + right[10];
result[11] = left[11] + right[11];
result[12] = left[12] + right[12];
result[13] = left[13] + right[13];
result[14] = left[14] + right[14];
result[15] = left[15] + right[15];
return result;
};
/**
* Computes the difference of two matrices.
*
* @param {Matrix4} left The first matrix.
* @param {Matrix4} right The second matrix.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.subtract = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
result[0] = left[0] - right[0];
result[1] = left[1] - right[1];
result[2] = left[2] - right[2];
result[3] = left[3] - right[3];
result[4] = left[4] - right[4];
result[5] = left[5] - right[5];
result[6] = left[6] - right[6];
result[7] = left[7] - right[7];
result[8] = left[8] - right[8];
result[9] = left[9] - right[9];
result[10] = left[10] - right[10];
result[11] = left[11] - right[11];
result[12] = left[12] - right[12];
result[13] = left[13] - right[13];
result[14] = left[14] - right[14];
result[15] = left[15] - right[15];
return result;
};
/**
* Computes the product of two matrices assuming the matrices are
* affine transformation matrices, where the upper left 3x3 elements
* are a rotation matrix, and the upper three elements in the fourth
* column are the translation. The bottom row is assumed to be [0, 0, 0, 1].
* The matrix is not verified to be in the proper form.
* This method is faster than computing the product for general 4x4
* matrices using {@link Matrix4.multiply}.
*
* @param {Matrix4} left The first matrix.
* @param {Matrix4} right The second matrix.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @example
* var m1 = new Cesium.Matrix4(1.0, 6.0, 7.0, 0.0, 2.0, 5.0, 8.0, 0.0, 3.0, 4.0, 9.0, 0.0, 0.0, 0.0, 0.0, 1.0);
* var m2 = Cesium.Transforms.eastNorthUpToFixedFrame(new Cesium.Cartesian3(1.0, 1.0, 1.0));
* var m3 = Cesium.Matrix4.multiplyTransformation(m1, m2, new Cesium.Matrix4());
*/
Matrix4.multiplyTransformation = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Check.typeOf.object('result', result);
var left0 = left[0];
var left1 = left[1];
var left2 = left[2];
var left4 = left[4];
var left5 = left[5];
var left6 = left[6];
var left8 = left[8];
var left9 = left[9];
var left10 = left[10];
var left12 = left[12];
var left13 = left[13];
var left14 = left[14];
var right0 = right[0];
var right1 = right[1];
var right2 = right[2];
var right4 = right[4];
var right5 = right[5];
var right6 = right[6];
var right8 = right[8];
var right9 = right[9];
var right10 = right[10];
var right12 = right[12];
var right13 = right[13];
var right14 = right[14];
var column0Row0 = left0 * right0 + left4 * right1 + left8 * right2;
var column0Row1 = left1 * right0 + left5 * right1 + left9 * right2;
var column0Row2 = left2 * right0 + left6 * right1 + left10 * right2;
var column1Row0 = left0 * right4 + left4 * right5 + left8 * right6;
var column1Row1 = left1 * right4 + left5 * right5 + left9 * right6;
var column1Row2 = left2 * right4 + left6 * right5 + left10 * right6;
var column2Row0 = left0 * right8 + left4 * right9 + left8 * right10;
var column2Row1 = left1 * right8 + left5 * right9 + left9 * right10;
var column2Row2 = left2 * right8 + left6 * right9 + left10 * right10;
var column3Row0 = left0 * right12 + left4 * right13 + left8 * right14 + left12;
var column3Row1 = left1 * right12 + left5 * right13 + left9 * right14 + left13;
var column3Row2 = left2 * right12 + left6 * right13 + left10 * right14 + left14;
result[0] = column0Row0;
result[1] = column0Row1;
result[2] = column0Row2;
result[3] = 0.0;
result[4] = column1Row0;
result[5] = column1Row1;
result[6] = column1Row2;
result[7] = 0.0;
result[8] = column2Row0;
result[9] = column2Row1;
result[10] = column2Row2;
result[11] = 0.0;
result[12] = column3Row0;
result[13] = column3Row1;
result[14] = column3Row2;
result[15] = 1.0;
return result;
};
/**
* Multiplies a transformation matrix (with a bottom row of <code>[0.0, 0.0, 0.0, 1.0]</code>)
* by a 3x3 rotation matrix. This is an optimization
* for <code>Matrix4.multiply(m, Matrix4.fromRotationTranslation(rotation), m);</code> with less allocations and arithmetic operations.
*
* @param {Matrix4} matrix The matrix on the left-hand side.
* @param {Matrix3} rotation The 3x3 rotation matrix on the right-hand side.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @example
* // Instead of Cesium.Matrix4.multiply(m, Cesium.Matrix4.fromRotationTranslation(rotation), m);
* Cesium.Matrix4.multiplyByMatrix3(m, rotation, m);
*/
Matrix4.multiplyByMatrix3 = function(matrix, rotation, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('rotation', rotation);
Check.typeOf.object('result', result);
var left0 = matrix[0];
var left1 = matrix[1];
var left2 = matrix[2];
var left4 = matrix[4];
var left5 = matrix[5];
var left6 = matrix[6];
var left8 = matrix[8];
var left9 = matrix[9];
var left10 = matrix[10];
var right0 = rotation[0];
var right1 = rotation[1];
var right2 = rotation[2];
var right4 = rotation[3];
var right5 = rotation[4];
var right6 = rotation[5];
var right8 = rotation[6];
var right9 = rotation[7];
var right10 = rotation[8];
var column0Row0 = left0 * right0 + left4 * right1 + left8 * right2;
var column0Row1 = left1 * right0 + left5 * right1 + left9 * right2;
var column0Row2 = left2 * right0 + left6 * right1 + left10 * right2;
var column1Row0 = left0 * right4 + left4 * right5 + left8 * right6;
var column1Row1 = left1 * right4 + left5 * right5 + left9 * right6;
var column1Row2 = left2 * right4 + left6 * right5 + left10 * right6;
var column2Row0 = left0 * right8 + left4 * right9 + left8 * right10;
var column2Row1 = left1 * right8 + left5 * right9 + left9 * right10;
var column2Row2 = left2 * right8 + left6 * right9 + left10 * right10;
result[0] = column0Row0;
result[1] = column0Row1;
result[2] = column0Row2;
result[3] = 0.0;
result[4] = column1Row0;
result[5] = column1Row1;
result[6] = column1Row2;
result[7] = 0.0;
result[8] = column2Row0;
result[9] = column2Row1;
result[10] = column2Row2;
result[11] = 0.0;
result[12] = matrix[12];
result[13] = matrix[13];
result[14] = matrix[14];
result[15] = matrix[15];
return result;
};
/**
* Multiplies a transformation matrix (with a bottom row of <code>[0.0, 0.0, 0.0, 1.0]</code>)
* by an implicit translation matrix defined by a {@link Cartesian3}. This is an optimization
* for <code>Matrix4.multiply(m, Matrix4.fromTranslation(position), m);</code> with less allocations and arithmetic operations.
*
* @param {Matrix4} matrix The matrix on the left-hand side.
* @param {Cartesian3} translation The translation on the right-hand side.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @example
* // Instead of Cesium.Matrix4.multiply(m, Cesium.Matrix4.fromTranslation(position), m);
* Cesium.Matrix4.multiplyByTranslation(m, position, m);
*/
Matrix4.multiplyByTranslation = function(matrix, translation, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('translation', translation);
Check.typeOf.object('result', result);
var x = translation.x;
var y = translation.y;
var z = translation.z;
var tx = (x * matrix[0]) + (y * matrix[4]) + (z * matrix[8]) + matrix[12];
var ty = (x * matrix[1]) + (y * matrix[5]) + (z * matrix[9]) + matrix[13];
var tz = (x * matrix[2]) + (y * matrix[6]) + (z * matrix[10]) + matrix[14];
result[0] = matrix[0];
result[1] = matrix[1];
result[2] = matrix[2];
result[3] = matrix[3];
result[4] = matrix[4];
result[5] = matrix[5];
result[6] = matrix[6];
result[7] = matrix[7];
result[8] = matrix[8];
result[9] = matrix[9];
result[10] = matrix[10];
result[11] = matrix[11];
result[12] = tx;
result[13] = ty;
result[14] = tz;
result[15] = matrix[15];
return result;
};
var uniformScaleScratch = new Cartesian3();
/**
* Multiplies an affine transformation matrix (with a bottom row of <code>[0.0, 0.0, 0.0, 1.0]</code>)
* by an implicit uniform scale matrix. This is an optimization
* for <code>Matrix4.multiply(m, Matrix4.fromUniformScale(scale), m);</code>, where
* <code>m</code> must be an affine matrix.
* This function performs fewer allocations and arithmetic operations.
*
* @param {Matrix4} matrix The affine matrix on the left-hand side.
* @param {Number} scale The uniform scale on the right-hand side.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
*
* @example
* // Instead of Cesium.Matrix4.multiply(m, Cesium.Matrix4.fromUniformScale(scale), m);
* Cesium.Matrix4.multiplyByUniformScale(m, scale, m);
*
* @see Matrix4.fromUniformScale
* @see Matrix4.multiplyByScale
*/
Matrix4.multiplyByUniformScale = function(matrix, scale, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number('scale', scale);
Check.typeOf.object('result', result);
uniformScaleScratch.x = scale;
uniformScaleScratch.y = scale;
uniformScaleScratch.z = scale;
return Matrix4.multiplyByScale(matrix, uniformScaleScratch, result);
};
/**
* Multiplies an affine transformation matrix (with a bottom row of <code>[0.0, 0.0, 0.0, 1.0]</code>)
* by an implicit non-uniform scale matrix. This is an optimization
* for <code>Matrix4.multiply(m, Matrix4.fromUniformScale(scale), m);</code>, where
* <code>m</code> must be an affine matrix.
* This function performs fewer allocations and arithmetic operations.
*
* @param {Matrix4} matrix The affine matrix on the left-hand side.
* @param {Cartesian3} scale The non-uniform scale on the right-hand side.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
*
* @example
* // Instead of Cesium.Matrix4.multiply(m, Cesium.Matrix4.fromScale(scale), m);
* Cesium.Matrix4.multiplyByScale(m, scale, m);
*
* @see Matrix4.fromScale
* @see Matrix4.multiplyByUniformScale
*/
Matrix4.multiplyByScale = function(matrix, scale, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('scale', scale);
Check.typeOf.object('result', result);
var scaleX = scale.x;
var scaleY = scale.y;
var scaleZ = scale.z;
// Faster than Cartesian3.equals
if ((scaleX === 1.0) && (scaleY === 1.0) && (scaleZ === 1.0)) {
return Matrix4.clone(matrix, result);
}
result[0] = scaleX * matrix[0];
result[1] = scaleX * matrix[1];
result[2] = scaleX * matrix[2];
result[3] = 0.0;
result[4] = scaleY * matrix[4];
result[5] = scaleY * matrix[5];
result[6] = scaleY * matrix[6];
result[7] = 0.0;
result[8] = scaleZ * matrix[8];
result[9] = scaleZ * matrix[9];
result[10] = scaleZ * matrix[10];
result[11] = 0.0;
result[12] = matrix[12];
result[13] = matrix[13];
result[14] = matrix[14];
result[15] = 1.0;
return result;
};
/**
* Computes the product of a matrix and a column vector.
*
* @param {Matrix4} matrix The matrix.
* @param {Cartesian4} cartesian The vector.
* @param {Cartesian4} result The object onto which to store the result.
* @returns {Cartesian4} The modified result parameter.
*/
Matrix4.multiplyByVector = function(matrix, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var vX = cartesian.x;
var vY = cartesian.y;
var vZ = cartesian.z;
var vW = cartesian.w;
var x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ + matrix[12] * vW;
var y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ + matrix[13] * vW;
var z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ + matrix[14] * vW;
var w = matrix[3] * vX + matrix[7] * vY + matrix[11] * vZ + matrix[15] * vW;
result.x = x;
result.y = y;
result.z = z;
result.w = w;
return result;
};
/**
* Computes the product of a matrix and a {@link Cartesian3}. This is equivalent to calling {@link Matrix4.multiplyByVector}
* with a {@link Cartesian4} with a <code>w</code> component of zero.
*
* @param {Matrix4} matrix The matrix.
* @param {Cartesian3} cartesian The point.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*
* @example
* var p = new Cesium.Cartesian3(1.0, 2.0, 3.0);
* var result = Cesium.Matrix4.multiplyByPointAsVector(matrix, p, new Cesium.Cartesian3());
* // A shortcut for
* // Cartesian3 p = ...
* // Cesium.Matrix4.multiplyByVector(matrix, new Cesium.Cartesian4(p.x, p.y, p.z, 0.0), result);
*/
Matrix4.multiplyByPointAsVector = function(matrix, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var vX = cartesian.x;
var vY = cartesian.y;
var vZ = cartesian.z;
var x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ;
var y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ;
var z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ;
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Computes the product of a matrix and a {@link Cartesian3}. This is equivalent to calling {@link Matrix4.multiplyByVector}
* with a {@link Cartesian4} with a <code>w</code> component of 1, but returns a {@link Cartesian3} instead of a {@link Cartesian4}.
*
* @param {Matrix4} matrix The matrix.
* @param {Cartesian3} cartesian The point.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*
* @example
* var p = new Cesium.Cartesian3(1.0, 2.0, 3.0);
* var result = Cesium.Matrix4.multiplyByPoint(matrix, p, new Cesium.Cartesian3());
*/
Matrix4.multiplyByPoint = function(matrix, cartesian, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var vX = cartesian.x;
var vY = cartesian.y;
var vZ = cartesian.z;
var x = matrix[0] * vX + matrix[4] * vY + matrix[8] * vZ + matrix[12];
var y = matrix[1] * vX + matrix[5] * vY + matrix[9] * vZ + matrix[13];
var z = matrix[2] * vX + matrix[6] * vY + matrix[10] * vZ + matrix[14];
result.x = x;
result.y = y;
result.z = z;
return result;
};
/**
* Computes the product of a matrix and a scalar.
*
* @param {Matrix4} matrix The matrix.
* @param {Number} scalar The number to multiply by.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @example
* //create a Matrix4 instance which is a scaled version of the supplied Matrix4
* // m = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [18.0, 19.0, 20.0, 21.0]
* // [22.0, 23.0, 24.0, 25.0]
*
* var a = Cesium.Matrix4.multiplyByScalar(m, -2, new Cesium.Matrix4());
*
* // m remains the same
* // a = [-20.0, -22.0, -24.0, -26.0]
* // [-28.0, -30.0, -32.0, -34.0]
* // [-36.0, -38.0, -40.0, -42.0]
* // [-44.0, -46.0, -48.0, -50.0]
*/
Matrix4.multiplyByScalar = function(matrix, scalar, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.number('scalar', scalar);
Check.typeOf.object('result', result);
result[0] = matrix[0] * scalar;
result[1] = matrix[1] * scalar;
result[2] = matrix[2] * scalar;
result[3] = matrix[3] * scalar;
result[4] = matrix[4] * scalar;
result[5] = matrix[5] * scalar;
result[6] = matrix[6] * scalar;
result[7] = matrix[7] * scalar;
result[8] = matrix[8] * scalar;
result[9] = matrix[9] * scalar;
result[10] = matrix[10] * scalar;
result[11] = matrix[11] * scalar;
result[12] = matrix[12] * scalar;
result[13] = matrix[13] * scalar;
result[14] = matrix[14] * scalar;
result[15] = matrix[15] * scalar;
return result;
};
/**
* Computes a negated copy of the provided matrix.
*
* @param {Matrix4} matrix The matrix to negate.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @example
* //create a new Matrix4 instance which is a negation of a Matrix4
* // m = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [18.0, 19.0, 20.0, 21.0]
* // [22.0, 23.0, 24.0, 25.0]
*
* var a = Cesium.Matrix4.negate(m, new Cesium.Matrix4());
*
* // m remains the same
* // a = [-10.0, -11.0, -12.0, -13.0]
* // [-14.0, -15.0, -16.0, -17.0]
* // [-18.0, -19.0, -20.0, -21.0]
* // [-22.0, -23.0, -24.0, -25.0]
*/
Matrix4.negate = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result[0] = -matrix[0];
result[1] = -matrix[1];
result[2] = -matrix[2];
result[3] = -matrix[3];
result[4] = -matrix[4];
result[5] = -matrix[5];
result[6] = -matrix[6];
result[7] = -matrix[7];
result[8] = -matrix[8];
result[9] = -matrix[9];
result[10] = -matrix[10];
result[11] = -matrix[11];
result[12] = -matrix[12];
result[13] = -matrix[13];
result[14] = -matrix[14];
result[15] = -matrix[15];
return result;
};
/**
* Computes the transpose of the provided matrix.
*
* @param {Matrix4} matrix The matrix to transpose.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @example
* //returns transpose of a Matrix4
* // m = [10.0, 11.0, 12.0, 13.0]
* // [14.0, 15.0, 16.0, 17.0]
* // [18.0, 19.0, 20.0, 21.0]
* // [22.0, 23.0, 24.0, 25.0]
*
* var a = Cesium.Matrix4.transpose(m, new Cesium.Matrix4());
*
* // m remains the same
* // a = [10.0, 14.0, 18.0, 22.0]
* // [11.0, 15.0, 19.0, 23.0]
* // [12.0, 16.0, 20.0, 24.0]
* // [13.0, 17.0, 21.0, 25.0]
*/
Matrix4.transpose = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
var matrix1 = matrix[1];
var matrix2 = matrix[2];
var matrix3 = matrix[3];
var matrix6 = matrix[6];
var matrix7 = matrix[7];
var matrix11 = matrix[11];
result[0] = matrix[0];
result[1] = matrix[4];
result[2] = matrix[8];
result[3] = matrix[12];
result[4] = matrix1;
result[5] = matrix[5];
result[6] = matrix[9];
result[7] = matrix[13];
result[8] = matrix2;
result[9] = matrix6;
result[10] = matrix[10];
result[11] = matrix[14];
result[12] = matrix3;
result[13] = matrix7;
result[14] = matrix11;
result[15] = matrix[15];
return result;
};
/**
* Computes a matrix, which contains the absolute (unsigned) values of the provided matrix's elements.
*
* @param {Matrix4} matrix The matrix with signed elements.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.abs = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result[0] = Math.abs(matrix[0]);
result[1] = Math.abs(matrix[1]);
result[2] = Math.abs(matrix[2]);
result[3] = Math.abs(matrix[3]);
result[4] = Math.abs(matrix[4]);
result[5] = Math.abs(matrix[5]);
result[6] = Math.abs(matrix[6]);
result[7] = Math.abs(matrix[7]);
result[8] = Math.abs(matrix[8]);
result[9] = Math.abs(matrix[9]);
result[10] = Math.abs(matrix[10]);
result[11] = Math.abs(matrix[11]);
result[12] = Math.abs(matrix[12]);
result[13] = Math.abs(matrix[13]);
result[14] = Math.abs(matrix[14]);
result[15] = Math.abs(matrix[15]);
return result;
};
/**
* Compares the provided matrices componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Matrix4} [left] The first matrix.
* @param {Matrix4} [right] The second matrix.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*
* @example
* //compares two Matrix4 instances
*
* // a = [10.0, 14.0, 18.0, 22.0]
* // [11.0, 15.0, 19.0, 23.0]
* // [12.0, 16.0, 20.0, 24.0]
* // [13.0, 17.0, 21.0, 25.0]
*
* // b = [10.0, 14.0, 18.0, 22.0]
* // [11.0, 15.0, 19.0, 23.0]
* // [12.0, 16.0, 20.0, 24.0]
* // [13.0, 17.0, 21.0, 25.0]
*
* if(Cesium.Matrix4.equals(a,b)) {
* console.log("Both matrices are equal");
* } else {
* console.log("They are not equal");
* }
*
* //Prints "Both matrices are equal" on the console
*/
Matrix4.equals = function(left, right) {
// Given that most matrices will be transformation matrices, the elements
// are tested in order such that the test is likely to fail as early
// as possible. I _think_ this is just as friendly to the L1 cache
// as testing in index order. It is certainty faster in practice.
return (left === right) ||
(defined(left) &&
defined(right) &&
// Translation
left[12] === right[12] &&
left[13] === right[13] &&
left[14] === right[14] &&
// Rotation/scale
left[0] === right[0] &&
left[1] === right[1] &&
left[2] === right[2] &&
left[4] === right[4] &&
left[5] === right[5] &&
left[6] === right[6] &&
left[8] === right[8] &&
left[9] === right[9] &&
left[10] === right[10] &&
// Bottom row
left[3] === right[3] &&
left[7] === right[7] &&
left[11] === right[11] &&
left[15] === right[15]);
};
/**
* Compares the provided matrices componentwise and returns
* <code>true</code> if they are within the provided epsilon,
* <code>false</code> otherwise.
*
* @param {Matrix4} [left] The first matrix.
* @param {Matrix4} [right] The second matrix.
* @param {Number} epsilon The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
*
* @example
* //compares two Matrix4 instances
*
* // a = [10.5, 14.5, 18.5, 22.5]
* // [11.5, 15.5, 19.5, 23.5]
* // [12.5, 16.5, 20.5, 24.5]
* // [13.5, 17.5, 21.5, 25.5]
*
* // b = [10.0, 14.0, 18.0, 22.0]
* // [11.0, 15.0, 19.0, 23.0]
* // [12.0, 16.0, 20.0, 24.0]
* // [13.0, 17.0, 21.0, 25.0]
*
* if(Cesium.Matrix4.equalsEpsilon(a,b,0.1)){
* console.log("Difference between both the matrices is less than 0.1");
* } else {
* console.log("Difference between both the matrices is not less than 0.1");
* }
*
* //Prints "Difference between both the matrices is not less than 0.1" on the console
*/
Matrix4.equalsEpsilon = function(left, right, epsilon) {
Check.typeOf.number('epsilon', epsilon);
return (left === right) ||
(defined(left) &&
defined(right) &&
Math.abs(left[0] - right[0]) <= epsilon &&
Math.abs(left[1] - right[1]) <= epsilon &&
Math.abs(left[2] - right[2]) <= epsilon &&
Math.abs(left[3] - right[3]) <= epsilon &&
Math.abs(left[4] - right[4]) <= epsilon &&
Math.abs(left[5] - right[5]) <= epsilon &&
Math.abs(left[6] - right[6]) <= epsilon &&
Math.abs(left[7] - right[7]) <= epsilon &&
Math.abs(left[8] - right[8]) <= epsilon &&
Math.abs(left[9] - right[9]) <= epsilon &&
Math.abs(left[10] - right[10]) <= epsilon &&
Math.abs(left[11] - right[11]) <= epsilon &&
Math.abs(left[12] - right[12]) <= epsilon &&
Math.abs(left[13] - right[13]) <= epsilon &&
Math.abs(left[14] - right[14]) <= epsilon &&
Math.abs(left[15] - right[15]) <= epsilon);
};
/**
* Gets the translation portion of the provided matrix, assuming the matrix is a affine transformation matrix.
*
* @param {Matrix4} matrix The matrix to use.
* @param {Cartesian3} result The object onto which to store the result.
* @returns {Cartesian3} The modified result parameter.
*/
Matrix4.getTranslation = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result.x = matrix[12];
result.y = matrix[13];
result.z = matrix[14];
return result;
};
/**
* Gets the upper left 3x3 rotation matrix of the provided matrix, assuming the matrix is a affine transformation matrix.
*
* @param {Matrix4} matrix The matrix to use.
* @param {Matrix3} result The object onto which to store the result.
* @returns {Matrix3} The modified result parameter.
*
* @example
* // returns a Matrix3 instance from a Matrix4 instance
*
* // m = [10.0, 14.0, 18.0, 22.0]
* // [11.0, 15.0, 19.0, 23.0]
* // [12.0, 16.0, 20.0, 24.0]
* // [13.0, 17.0, 21.0, 25.0]
*
* var b = new Cesium.Matrix3();
* Cesium.Matrix4.getRotation(m,b);
*
* // b = [10.0, 14.0, 18.0]
* // [11.0, 15.0, 19.0]
* // [12.0, 16.0, 20.0]
*/
Matrix4.getRotation = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
result[0] = matrix[0];
result[1] = matrix[1];
result[2] = matrix[2];
result[3] = matrix[4];
result[4] = matrix[5];
result[5] = matrix[6];
result[6] = matrix[8];
result[7] = matrix[9];
result[8] = matrix[10];
return result;
};
var scratchInverseRotation = new Matrix3();
var scratchMatrix3Zero = new Matrix3();
var scratchBottomRow = new Cartesian4();
var scratchExpectedBottomRow = new Cartesian4(0.0, 0.0, 0.0, 1.0);
/**
* Computes the inverse of the provided matrix using Cramers Rule.
* If the determinant is zero, the matrix can not be inverted, and an exception is thrown.
* If the matrix is an affine transformation matrix, it is more efficient
* to invert it with {@link Matrix4.inverseTransformation}.
*
* @param {Matrix4} matrix The matrix to invert.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*
* @exception {RuntimeError} matrix is not invertible because its determinate is zero.
*/
Matrix4.inverse = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
// Special case for a zero scale matrix that can occur, for example,
// when a model's node has a [0, 0, 0] scale.
if (Matrix3.equalsEpsilon(Matrix4.getRotation(matrix, scratchInverseRotation), scratchMatrix3Zero, CesiumMath.EPSILON7) &&
Cartesian4.equals(Matrix4.getRow(matrix, 3, scratchBottomRow), scratchExpectedBottomRow)) {
result[0] = 0.0;
result[1] = 0.0;
result[2] = 0.0;
result[3] = 0.0;
result[4] = 0.0;
result[5] = 0.0;
result[6] = 0.0;
result[7] = 0.0;
result[8] = 0.0;
result[9] = 0.0;
result[10] = 0.0;
result[11] = 0.0;
result[12] = -matrix[12];
result[13] = -matrix[13];
result[14] = -matrix[14];
result[15] = 1.0;
return result;
}
//
// Ported from:
// ftp://download.intel.com/design/PentiumIII/sml/24504301.pdf
//
var src0 = matrix[0];
var src1 = matrix[4];
var src2 = matrix[8];
var src3 = matrix[12];
var src4 = matrix[1];
var src5 = matrix[5];
var src6 = matrix[9];
var src7 = matrix[13];
var src8 = matrix[2];
var src9 = matrix[6];
var src10 = matrix[10];
var src11 = matrix[14];
var src12 = matrix[3];
var src13 = matrix[7];
var src14 = matrix[11];
var src15 = matrix[15];
// calculate pairs for first 8 elements (cofactors)
var tmp0 = src10 * src15;
var tmp1 = src11 * src14;
var tmp2 = src9 * src15;
var tmp3 = src11 * src13;
var tmp4 = src9 * src14;
var tmp5 = src10 * src13;
var tmp6 = src8 * src15;
var tmp7 = src11 * src12;
var tmp8 = src8 * src14;
var tmp9 = src10 * src12;
var tmp10 = src8 * src13;
var tmp11 = src9 * src12;
// calculate first 8 elements (cofactors)
var dst0 = (tmp0 * src5 + tmp3 * src6 + tmp4 * src7) - (tmp1 * src5 + tmp2 * src6 + tmp5 * src7);
var dst1 = (tmp1 * src4 + tmp6 * src6 + tmp9 * src7) - (tmp0 * src4 + tmp7 * src6 + tmp8 * src7);
var dst2 = (tmp2 * src4 + tmp7 * src5 + tmp10 * src7) - (tmp3 * src4 + tmp6 * src5 + tmp11 * src7);
var dst3 = (tmp5 * src4 + tmp8 * src5 + tmp11 * src6) - (tmp4 * src4 + tmp9 * src5 + tmp10 * src6);
var dst4 = (tmp1 * src1 + tmp2 * src2 + tmp5 * src3) - (tmp0 * src1 + tmp3 * src2 + tmp4 * src3);
var dst5 = (tmp0 * src0 + tmp7 * src2 + tmp8 * src3) - (tmp1 * src0 + tmp6 * src2 + tmp9 * src3);
var dst6 = (tmp3 * src0 + tmp6 * src1 + tmp11 * src3) - (tmp2 * src0 + tmp7 * src1 + tmp10 * src3);
var dst7 = (tmp4 * src0 + tmp9 * src1 + tmp10 * src2) - (tmp5 * src0 + tmp8 * src1 + tmp11 * src2);
// calculate pairs for second 8 elements (cofactors)
tmp0 = src2 * src7;
tmp1 = src3 * src6;
tmp2 = src1 * src7;
tmp3 = src3 * src5;
tmp4 = src1 * src6;
tmp5 = src2 * src5;
tmp6 = src0 * src7;
tmp7 = src3 * src4;
tmp8 = src0 * src6;
tmp9 = src2 * src4;
tmp10 = src0 * src5;
tmp11 = src1 * src4;
// calculate second 8 elements (cofactors)
var dst8 = (tmp0 * src13 + tmp3 * src14 + tmp4 * src15) - (tmp1 * src13 + tmp2 * src14 + tmp5 * src15);
var dst9 = (tmp1 * src12 + tmp6 * src14 + tmp9 * src15) - (tmp0 * src12 + tmp7 * src14 + tmp8 * src15);
var dst10 = (tmp2 * src12 + tmp7 * src13 + tmp10 * src15) - (tmp3 * src12 + tmp6 * src13 + tmp11 * src15);
var dst11 = (tmp5 * src12 + tmp8 * src13 + tmp11 * src14) - (tmp4 * src12 + tmp9 * src13 + tmp10 * src14);
var dst12 = (tmp2 * src10 + tmp5 * src11 + tmp1 * src9) - (tmp4 * src11 + tmp0 * src9 + tmp3 * src10);
var dst13 = (tmp8 * src11 + tmp0 * src8 + tmp7 * src10) - (tmp6 * src10 + tmp9 * src11 + tmp1 * src8);
var dst14 = (tmp6 * src9 + tmp11 * src11 + tmp3 * src8) - (tmp10 * src11 + tmp2 * src8 + tmp7 * src9);
var dst15 = (tmp10 * src10 + tmp4 * src8 + tmp9 * src9) - (tmp8 * src9 + tmp11 * src10 + tmp5 * src8);
// calculate determinant
var det = src0 * dst0 + src1 * dst1 + src2 * dst2 + src3 * dst3;
if (Math.abs(det) < CesiumMath.EPSILON20) {
throw new RuntimeError('matrix is not invertible because its determinate is zero.');
}
// calculate matrix inverse
det = 1.0 / det;
result[0] = dst0 * det;
result[1] = dst1 * det;
result[2] = dst2 * det;
result[3] = dst3 * det;
result[4] = dst4 * det;
result[5] = dst5 * det;
result[6] = dst6 * det;
result[7] = dst7 * det;
result[8] = dst8 * det;
result[9] = dst9 * det;
result[10] = dst10 * det;
result[11] = dst11 * det;
result[12] = dst12 * det;
result[13] = dst13 * det;
result[14] = dst14 * det;
result[15] = dst15 * det;
return result;
};
/**
* Computes the inverse of the provided matrix assuming it is
* an affine transformation matrix, where the upper left 3x3 elements
* are a rotation matrix, and the upper three elements in the fourth
* column are the translation. The bottom row is assumed to be [0, 0, 0, 1].
* The matrix is not verified to be in the proper form.
* This method is faster than computing the inverse for a general 4x4
* matrix using {@link Matrix4.inverse}.
*
* @param {Matrix4} matrix The matrix to invert.
* @param {Matrix4} result The object onto which to store the result.
* @returns {Matrix4} The modified result parameter.
*/
Matrix4.inverseTransformation = function(matrix, result) {
Check.typeOf.object('matrix', matrix);
Check.typeOf.object('result', result);
//This function is an optimized version of the below 4 lines.
//var rT = Matrix3.transpose(Matrix4.getRotation(matrix));
//var rTN = Matrix3.negate(rT);
//var rTT = Matrix3.multiplyByVector(rTN, Matrix4.getTranslation(matrix));
//return Matrix4.fromRotationTranslation(rT, rTT, result);
var matrix0 = matrix[0];
var matrix1 = matrix[1];
var matrix2 = matrix[2];
var matrix4 = matrix[4];
var matrix5 = matrix[5];
var matrix6 = matrix[6];
var matrix8 = matrix[8];
var matrix9 = matrix[9];
var matrix10 = matrix[10];
var vX = matrix[12];
var vY = matrix[13];
var vZ = matrix[14];
var x = -matrix0 * vX - matrix1 * vY - matrix2 * vZ;
var y = -matrix4 * vX - matrix5 * vY - matrix6 * vZ;
var z = -matrix8 * vX - matrix9 * vY - matrix10 * vZ;
result[0] = matrix0;
result[1] = matrix4;
result[2] = matrix8;
result[3] = 0.0;
result[4] = matrix1;
result[5] = matrix5;
result[6] = matrix9;
result[7] = 0.0;
result[8] = matrix2;
result[9] = matrix6;
result[10] = matrix10;
result[11] = 0.0;
result[12] = x;
result[13] = y;
result[14] = z;
result[15] = 1.0;
return result;
};
/**
* An immutable Matrix4 instance initialized to the identity matrix.
*
* @type {Matrix4}
* @constant
*/
Matrix4.IDENTITY = freezeObject(new Matrix4(1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0));
/**
* An immutable Matrix4 instance initialized to the zero matrix.
*
* @type {Matrix4}
* @constant
*/
Matrix4.ZERO = freezeObject(new Matrix4(0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0));
/**
* The index into Matrix4 for column 0, row 0.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN0ROW0 = 0;
/**
* The index into Matrix4 for column 0, row 1.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN0ROW1 = 1;
/**
* The index into Matrix4 for column 0, row 2.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN0ROW2 = 2;
/**
* The index into Matrix4 for column 0, row 3.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN0ROW3 = 3;
/**
* The index into Matrix4 for column 1, row 0.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN1ROW0 = 4;
/**
* The index into Matrix4 for column 1, row 1.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN1ROW1 = 5;
/**
* The index into Matrix4 for column 1, row 2.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN1ROW2 = 6;
/**
* The index into Matrix4 for column 1, row 3.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN1ROW3 = 7;
/**
* The index into Matrix4 for column 2, row 0.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN2ROW0 = 8;
/**
* The index into Matrix4 for column 2, row 1.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN2ROW1 = 9;
/**
* The index into Matrix4 for column 2, row 2.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN2ROW2 = 10;
/**
* The index into Matrix4 for column 2, row 3.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN2ROW3 = 11;
/**
* The index into Matrix4 for column 3, row 0.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN3ROW0 = 12;
/**
* The index into Matrix4 for column 3, row 1.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN3ROW1 = 13;
/**
* The index into Matrix4 for column 3, row 2.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN3ROW2 = 14;
/**
* The index into Matrix4 for column 3, row 3.
*
* @type {Number}
* @constant
*/
Matrix4.COLUMN3ROW3 = 15;
defineProperties(Matrix4.prototype, {
/**
* Gets the number of items in the collection.
* @memberof Matrix4.prototype
*
* @type {Number}
*/
length : {
get : function() {
return Matrix4.packedLength;
}
}
});
/**
* Duplicates the provided Matrix4 instance.
*
* @param {Matrix4} [result] The object onto which to store the result.
* @returns {Matrix4} The modified result parameter or a new Matrix4 instance if one was not provided.
*/
Matrix4.prototype.clone = function(result) {
return Matrix4.clone(this, result);
};
/**
* Compares this matrix to the provided matrix componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Matrix4} [right] The right hand side matrix.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
Matrix4.prototype.equals = function(right) {
return Matrix4.equals(this, right);
};
/**
* @private
*/
Matrix4.equalsArray = function(matrix, array, offset) {
return matrix[0] === array[offset] &&
matrix[1] === array[offset + 1] &&
matrix[2] === array[offset + 2] &&
matrix[3] === array[offset + 3] &&
matrix[4] === array[offset + 4] &&
matrix[5] === array[offset + 5] &&
matrix[6] === array[offset + 6] &&
matrix[7] === array[offset + 7] &&
matrix[8] === array[offset + 8] &&
matrix[9] === array[offset + 9] &&
matrix[10] === array[offset + 10] &&
matrix[11] === array[offset + 11] &&
matrix[12] === array[offset + 12] &&
matrix[13] === array[offset + 13] &&
matrix[14] === array[offset + 14] &&
matrix[15] === array[offset + 15];
};
/**
* Compares this matrix to the provided matrix componentwise and returns
* <code>true</code> if they are within the provided epsilon,
* <code>false</code> otherwise.
*
* @param {Matrix4} [right] The right hand side matrix.
* @param {Number} epsilon The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
*/
Matrix4.prototype.equalsEpsilon = function(right, epsilon) {
return Matrix4.equalsEpsilon(this, right, epsilon);
};
/**
* Computes a string representing this Matrix with each row being
* on a separate line and in the format '(column0, column1, column2, column3)'.
*
* @returns {String} A string representing the provided Matrix with each row being on a separate line and in the format '(column0, column1, column2, column3)'.
*/
Matrix4.prototype.toString = function() {
return '(' + this[0] + ', ' + this[4] + ', ' + this[8] + ', ' + this[12] +')\n' +
'(' + this[1] + ', ' + this[5] + ', ' + this[9] + ', ' + this[13] +')\n' +
'(' + this[2] + ', ' + this[6] + ', ' + this[10] + ', ' + this[14] +')\n' +
'(' + this[3] + ', ' + this[7] + ', ' + this[11] + ', ' + this[15] +')';
};
return Matrix4;
});
/*global define*/
define('Core/Rectangle',[
'./Cartographic',
'./Check',
'./defaultValue',
'./defined',
'./defineProperties',
'./Ellipsoid',
'./freezeObject',
'./Math'
], function(
Cartographic,
Check,
defaultValue,
defined,
defineProperties,
Ellipsoid,
freezeObject,
CesiumMath) {
'use strict';
/**
* A two dimensional region specified as longitude and latitude coordinates.
*
* @alias Rectangle
* @constructor
*
* @param {Number} [west=0.0] The westernmost longitude, in radians, in the range [-Pi, Pi].
* @param {Number} [south=0.0] The southernmost latitude, in radians, in the range [-Pi/2, Pi/2].
* @param {Number} [east=0.0] The easternmost longitude, in radians, in the range [-Pi, Pi].
* @param {Number} [north=0.0] The northernmost latitude, in radians, in the range [-Pi/2, Pi/2].
*
* @see Packable
*/
function Rectangle(west, south, east, north) {
/**
* The westernmost longitude in radians in the range [-Pi, Pi].
*
* @type {Number}
* @default 0.0
*/
this.west = defaultValue(west, 0.0);
/**
* The southernmost latitude in radians in the range [-Pi/2, Pi/2].
*
* @type {Number}
* @default 0.0
*/
this.south = defaultValue(south, 0.0);
/**
* The easternmost longitude in radians in the range [-Pi, Pi].
*
* @type {Number}
* @default 0.0
*/
this.east = defaultValue(east, 0.0);
/**
* The northernmost latitude in radians in the range [-Pi/2, Pi/2].
*
* @type {Number}
* @default 0.0
*/
this.north = defaultValue(north, 0.0);
}
defineProperties(Rectangle.prototype, {
/**
* Gets the width of the rectangle in radians.
* @memberof Rectangle.prototype
* @type {Number}
*/
width : {
get : function() {
return Rectangle.computeWidth(this);
}
},
/**
* Gets the height of the rectangle in radians.
* @memberof Rectangle.prototype
* @type {Number}
*/
height : {
get : function() {
return Rectangle.computeHeight(this);
}
}
});
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Rectangle.packedLength = 4;
/**
* Stores the provided instance into the provided array.
*
* @param {Rectangle} 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
*/
Rectangle.pack = function(value, array, startingIndex) {
Check.typeOf.object('value', value);
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value.west;
array[startingIndex++] = value.south;
array[startingIndex++] = value.east;
array[startingIndex] = value.north;
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 {Rectangle} [result] The object into which to store the result.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if one was not provided.
*/
Rectangle.unpack = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Rectangle();
}
result.west = array[startingIndex++];
result.south = array[startingIndex++];
result.east = array[startingIndex++];
result.north = array[startingIndex];
return result;
};
/**
* Computes the width of a rectangle in radians.
* @param {Rectangle} rectangle The rectangle to compute the width of.
* @returns {Number} The width.
*/
Rectangle.computeWidth = function(rectangle) {
Check.typeOf.object('rectangle', rectangle);
var east = rectangle.east;
var west = rectangle.west;
if (east < west) {
east += CesiumMath.TWO_PI;
}
return east - west;
};
/**
* Computes the height of a rectangle in radians.
* @param {Rectangle} rectangle The rectangle to compute the height of.
* @returns {Number} The height.
*/
Rectangle.computeHeight = function(rectangle) {
Check.typeOf.object('rectangle', rectangle);
return rectangle.north - rectangle.south;
};
/**
* Creates a rectangle given the boundary longitude and latitude in degrees.
*
* @param {Number} [west=0.0] The westernmost longitude in degrees in the range [-180.0, 180.0].
* @param {Number} [south=0.0] The southernmost latitude in degrees in the range [-90.0, 90.0].
* @param {Number} [east=0.0] The easternmost longitude in degrees in the range [-180.0, 180.0].
* @param {Number} [north=0.0] The northernmost latitude in degrees in the range [-90.0, 90.0].
* @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
*
* @example
* var rectangle = Cesium.Rectangle.fromDegrees(0.0, 20.0, 10.0, 30.0);
*/
Rectangle.fromDegrees = function(west, south, east, north, result) {
west = CesiumMath.toRadians(defaultValue(west, 0.0));
south = CesiumMath.toRadians(defaultValue(south, 0.0));
east = CesiumMath.toRadians(defaultValue(east, 0.0));
north = CesiumMath.toRadians(defaultValue(north, 0.0));
if (!defined(result)) {
return new Rectangle(west, south, east, north);
}
result.west = west;
result.south = south;
result.east = east;
result.north = north;
return result;
};
/**
* Creates an rectangle given the boundary longitude and latitude in radians.
*
* @param {Number} [west=0.0] The westernmost longitude in radians in the range [-Math.PI, Math.PI].
* @param {Number} [south=0.0] The southernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
* @param {Number} [east=0.0] The easternmost longitude in radians in the range [-Math.PI, Math.PI].
* @param {Number} [north=0.0] The northernmost latitude in radians in the range [-Math.PI/2, Math.PI/2].
* @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
*
* @example
* var rectangle = Cesium.Rectangle.fromRadians(0.0, Math.PI/4, Math.PI/8, 3*Math.PI/4);
*/
Rectangle.fromRadians = function(west, south, east, north, result) {
if (!defined(result)) {
return new Rectangle(west, south, east, north);
}
result.west = defaultValue(west, 0.0);
result.south = defaultValue(south, 0.0);
result.east = defaultValue(east, 0.0);
result.north = defaultValue(north, 0.0);
return result;
};
/**
* Creates the smallest possible Rectangle that encloses all positions in the provided array.
*
* @param {Cartographic[]} cartographics The list of Cartographic instances.
* @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
*/
Rectangle.fromCartographicArray = function(cartographics, result) {
Check.defined('cartographics', cartographics);
var west = Number.MAX_VALUE;
var east = -Number.MAX_VALUE;
var westOverIDL = Number.MAX_VALUE;
var eastOverIDL = -Number.MAX_VALUE;
var south = Number.MAX_VALUE;
var north = -Number.MAX_VALUE;
for ( var i = 0, len = cartographics.length; i < len; i++) {
var position = cartographics[i];
west = Math.min(west, position.longitude);
east = Math.max(east, position.longitude);
south = Math.min(south, position.latitude);
north = Math.max(north, position.latitude);
var lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + CesiumMath.TWO_PI;
westOverIDL = Math.min(westOverIDL, lonAdjusted);
eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
}
if(east - west > eastOverIDL - westOverIDL) {
west = westOverIDL;
east = eastOverIDL;
if (east > CesiumMath.PI) {
east = east - CesiumMath.TWO_PI;
}
if (west > CesiumMath.PI) {
west = west - CesiumMath.TWO_PI;
}
}
if (!defined(result)) {
return new Rectangle(west, south, east, north);
}
result.west = west;
result.south = south;
result.east = east;
result.north = north;
return result;
};
/**
* Creates the smallest possible Rectangle that encloses all positions in the provided array.
*
* @param {Cartesian[]} cartesians The list of Cartesian instances.
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid the cartesians are on.
* @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
*/
Rectangle.fromCartesianArray = function(cartesians, ellipsoid, result) {
Check.defined('cartesians', cartesians);
var west = Number.MAX_VALUE;
var east = -Number.MAX_VALUE;
var westOverIDL = Number.MAX_VALUE;
var eastOverIDL = -Number.MAX_VALUE;
var south = Number.MAX_VALUE;
var north = -Number.MAX_VALUE;
for ( var i = 0, len = cartesians.length; i < len; i++) {
var position = ellipsoid.cartesianToCartographic(cartesians[i]);
west = Math.min(west, position.longitude);
east = Math.max(east, position.longitude);
south = Math.min(south, position.latitude);
north = Math.max(north, position.latitude);
var lonAdjusted = position.longitude >= 0 ? position.longitude : position.longitude + CesiumMath.TWO_PI;
westOverIDL = Math.min(westOverIDL, lonAdjusted);
eastOverIDL = Math.max(eastOverIDL, lonAdjusted);
}
if(east - west > eastOverIDL - westOverIDL) {
west = westOverIDL;
east = eastOverIDL;
if (east > CesiumMath.PI) {
east = east - CesiumMath.TWO_PI;
}
if (west > CesiumMath.PI) {
west = west - CesiumMath.TWO_PI;
}
}
if (!defined(result)) {
return new Rectangle(west, south, east, north);
}
result.west = west;
result.south = south;
result.east = east;
result.north = north;
return result;
};
/**
* Duplicates a Rectangle.
*
* @param {Rectangle} rectangle The rectangle to clone.
* @param {Rectangle} [result] The object onto which to store the result, or undefined if a new instance should be created.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided. (Returns undefined if rectangle is undefined)
*/
Rectangle.clone = function(rectangle, result) {
if (!defined(rectangle)) {
return undefined;
}
if (!defined(result)) {
return new Rectangle(rectangle.west, rectangle.south, rectangle.east, rectangle.north);
}
result.west = rectangle.west;
result.south = rectangle.south;
result.east = rectangle.east;
result.north = rectangle.north;
return result;
};
/**
* Duplicates this Rectangle.
*
* @param {Rectangle} [result] The object onto which to store the result.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
*/
Rectangle.prototype.clone = function(result) {
return Rectangle.clone(this, result);
};
/**
* Compares the provided Rectangle with this Rectangle componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Rectangle} [other] The Rectangle to compare.
* @returns {Boolean} <code>true</code> if the Rectangles are equal, <code>false</code> otherwise.
*/
Rectangle.prototype.equals = function(other) {
return Rectangle.equals(this, other);
};
/**
* Compares the provided rectangles and returns <code>true</code> if they are equal,
* <code>false</code> otherwise.
*
* @param {Rectangle} [left] The first Rectangle.
* @param {Rectangle} [right] The second Rectangle.
* @returns {Boolean} <code>true</code> if left and right are equal; otherwise <code>false</code>.
*/
Rectangle.equals = function(left, right) {
return (left === right) ||
((defined(left)) &&
(defined(right)) &&
(left.west === right.west) &&
(left.south === right.south) &&
(left.east === right.east) &&
(left.north === right.north));
};
/**
* Compares the provided Rectangle with this Rectangle componentwise and returns
* <code>true</code> if they are within the provided epsilon,
* <code>false</code> otherwise.
*
* @param {Rectangle} [other] The Rectangle to compare.
* @param {Number} epsilon The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if the Rectangles are within the provided epsilon, <code>false</code> otherwise.
*/
Rectangle.prototype.equalsEpsilon = function(other, epsilon) {
Check.typeOf.number('epsilon', epsilon);
return defined(other) &&
(Math.abs(this.west - other.west) <= epsilon) &&
(Math.abs(this.south - other.south) <= epsilon) &&
(Math.abs(this.east - other.east) <= epsilon) &&
(Math.abs(this.north - other.north) <= epsilon);
};
/**
* Checks a Rectangle's properties and throws if they are not in valid ranges.
*
* @param {Rectangle} rectangle The rectangle to validate
*
* @exception {DeveloperError} <code>north</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
* @exception {DeveloperError} <code>south</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
* @exception {DeveloperError} <code>east</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
* @exception {DeveloperError} <code>west</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
*/
Rectangle.validate = function(rectangle) {
Check.typeOf.object('rectangle', rectangle);
var north = rectangle.north;
Check.typeOf.number.greaterThanOrEquals('north', north, -CesiumMath.PI_OVER_TWO);
Check.typeOf.number.lessThanOrEquals('north', north, CesiumMath.PI_OVER_TWO);
var south = rectangle.south;
Check.typeOf.number.greaterThanOrEquals('south', south, -CesiumMath.PI_OVER_TWO);
Check.typeOf.number.lessThanOrEquals('south', south, CesiumMath.PI_OVER_TWO);
var west = rectangle.west;
Check.typeOf.number.greaterThanOrEquals('west', west, -Math.PI);
Check.typeOf.number.lessThanOrEquals('west', west, Math.PI);
var east = rectangle.east;
Check.typeOf.number.greaterThanOrEquals('east', east, -Math.PI);
Check.typeOf.number.lessThanOrEquals('east', east, Math.PI);
};
/**
* Computes the southwest corner of a rectangle.
*
* @param {Rectangle} rectangle The rectangle for which to find the corner
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
*/
Rectangle.southwest = function(rectangle, result) {
Check.typeOf.object('rectangle', rectangle);
if (!defined(result)) {
return new Cartographic(rectangle.west, rectangle.south);
}
result.longitude = rectangle.west;
result.latitude = rectangle.south;
result.height = 0.0;
return result;
};
/**
* Computes the northwest corner of a rectangle.
*
* @param {Rectangle} rectangle The rectangle for which to find the corner
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
*/
Rectangle.northwest = function(rectangle, result) {
Check.typeOf.object('rectangle', rectangle);
if (!defined(result)) {
return new Cartographic(rectangle.west, rectangle.north);
}
result.longitude = rectangle.west;
result.latitude = rectangle.north;
result.height = 0.0;
return result;
};
/**
* Computes the northeast corner of a rectangle.
*
* @param {Rectangle} rectangle The rectangle for which to find the corner
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
*/
Rectangle.northeast = function(rectangle, result) {
Check.typeOf.object('rectangle', rectangle);
if (!defined(result)) {
return new Cartographic(rectangle.east, rectangle.north);
}
result.longitude = rectangle.east;
result.latitude = rectangle.north;
result.height = 0.0;
return result;
};
/**
* Computes the southeast corner of a rectangle.
*
* @param {Rectangle} rectangle The rectangle for which to find the corner
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
*/
Rectangle.southeast = function(rectangle, result) {
Check.typeOf.object('rectangle', rectangle);
if (!defined(result)) {
return new Cartographic(rectangle.east, rectangle.south);
}
result.longitude = rectangle.east;
result.latitude = rectangle.south;
result.height = 0.0;
return result;
};
/**
* Computes the center of a rectangle.
*
* @param {Rectangle} rectangle The rectangle for which to find the center
* @param {Cartographic} [result] The object onto which to store the result.
* @returns {Cartographic} The modified result parameter or a new Cartographic instance if none was provided.
*/
Rectangle.center = function(rectangle, result) {
Check.typeOf.object('rectangle', rectangle);
var east = rectangle.east;
var west = rectangle.west;
if (east < west) {
east += CesiumMath.TWO_PI;
}
var longitude = CesiumMath.negativePiToPi((west + east) * 0.5);
var latitude = (rectangle.south + rectangle.north) * 0.5;
if (!defined(result)) {
return new Cartographic(longitude, latitude);
}
result.longitude = longitude;
result.latitude = latitude;
result.height = 0.0;
return result;
};
/**
* Computes the intersection of two rectangles. This function assumes that the rectangle's coordinates are
* latitude and longitude in radians and produces a correct intersection, taking into account the fact that
* the same angle can be represented with multiple values as well as the wrapping of longitude at the
* anti-meridian. For a simple intersection that ignores these factors and can be used with projected
* coordinates, see {@link Rectangle.simpleIntersection}.
*
* @param {Rectangle} rectangle On rectangle to find an intersection
* @param {Rectangle} otherRectangle Another rectangle to find an intersection
* @param {Rectangle} [result] The object onto which to store the result.
* @returns {Rectangle|undefined} The modified result parameter, a new Rectangle instance if none was provided or undefined if there is no intersection.
*/
Rectangle.intersection = function(rectangle, otherRectangle, result) {
Check.typeOf.object('rectangle', rectangle);
Check.typeOf.object('otherRectangle', otherRectangle);
var rectangleEast = rectangle.east;
var rectangleWest = rectangle.west;
var otherRectangleEast = otherRectangle.east;
var otherRectangleWest = otherRectangle.west;
if (rectangleEast < rectangleWest && otherRectangleEast > 0.0) {
rectangleEast += CesiumMath.TWO_PI;
} else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0.0) {
otherRectangleEast += CesiumMath.TWO_PI;
}
if (rectangleEast < rectangleWest && otherRectangleWest < 0.0) {
otherRectangleWest += CesiumMath.TWO_PI;
} else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0.0) {
rectangleWest += CesiumMath.TWO_PI;
}
var west = CesiumMath.negativePiToPi(Math.max(rectangleWest, otherRectangleWest));
var east = CesiumMath.negativePiToPi(Math.min(rectangleEast, otherRectangleEast));
if ((rectangle.west < rectangle.east || otherRectangle.west < otherRectangle.east) && east <= west) {
return undefined;
}
var south = Math.max(rectangle.south, otherRectangle.south);
var north = Math.min(rectangle.north, otherRectangle.north);
if (south >= north) {
return undefined;
}
if (!defined(result)) {
return new Rectangle(west, south, east, north);
}
result.west = west;
result.south = south;
result.east = east;
result.north = north;
return result;
};
/**
* Computes a simple intersection of two rectangles. Unlike {@link Rectangle.intersection}, this function
* does not attempt to put the angular coordinates into a consistent range or to account for crossing the
* anti-meridian. As such, it can be used for rectangles where the coordinates are not simply latitude
* and longitude (i.e. projected coordinates).
*
* @param {Rectangle} rectangle On rectangle to find an intersection
* @param {Rectangle} otherRectangle Another rectangle to find an intersection
* @param {Rectangle} [result] The object onto which to store the result.
* @returns {Rectangle|undefined} The modified result parameter, a new Rectangle instance if none was provided or undefined if there is no intersection.
*/
Rectangle.simpleIntersection = function(rectangle, otherRectangle, result) {
Check.typeOf.object('rectangle', rectangle);
Check.typeOf.object('otherRectangle', otherRectangle);
var west = Math.max(rectangle.west, otherRectangle.west);
var south = Math.max(rectangle.south, otherRectangle.south);
var east = Math.min(rectangle.east, otherRectangle.east);
var north = Math.min(rectangle.north, otherRectangle.north);
if (south >= north || west >= east) {
return undefined;
}
if (!defined(result)) {
return new Rectangle(west, south, east, north);
}
result.west = west;
result.south = south;
result.east = east;
result.north = north;
return result;
};
/**
* Computes a rectangle that is the union of two rectangles.
*
* @param {Rectangle} rectangle A rectangle to enclose in rectangle.
* @param {Rectangle} otherRectangle A rectangle to enclose in a rectangle.
* @param {Rectangle} [result] The object onto which to store the result.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if none was provided.
*/
Rectangle.union = function(rectangle, otherRectangle, result) {
Check.typeOf.object('rectangle', rectangle);
Check.typeOf.object('otherRectangle', otherRectangle);
if (!defined(result)) {
result = new Rectangle();
}
var rectangleEast = rectangle.east;
var rectangleWest = rectangle.west;
var otherRectangleEast = otherRectangle.east;
var otherRectangleWest = otherRectangle.west;
if (rectangleEast < rectangleWest && otherRectangleEast > 0.0) {
rectangleEast += CesiumMath.TWO_PI;
} else if (otherRectangleEast < otherRectangleWest && rectangleEast > 0.0) {
otherRectangleEast += CesiumMath.TWO_PI;
}
if (rectangleEast < rectangleWest && otherRectangleWest < 0.0) {
otherRectangleWest += CesiumMath.TWO_PI;
} else if (otherRectangleEast < otherRectangleWest && rectangleWest < 0.0) {
rectangleWest += CesiumMath.TWO_PI;
}
var west = CesiumMath.convertLongitudeRange(Math.min(rectangleWest, otherRectangleWest));
var east = CesiumMath.convertLongitudeRange(Math.max(rectangleEast, otherRectangleEast));
result.west = west;
result.south = Math.min(rectangle.south, otherRectangle.south);
result.east = east;
result.north = Math.max(rectangle.north, otherRectangle.north);
return result;
};
/**
* Computes a rectangle by enlarging the provided rectangle until it contains the provided cartographic.
*
* @param {Rectangle} rectangle A rectangle to expand.
* @param {Cartographic} cartographic A cartographic to enclose in a rectangle.
* @param {Rectangle} [result] The object onto which to store the result.
* @returns {Rectangle} The modified result parameter or a new Rectangle instance if one was not provided.
*/
Rectangle.expand = function(rectangle, cartographic, result) {
Check.typeOf.object('rectangle', rectangle);
Check.typeOf.object('cartographic', cartographic);
if (!defined(result)) {
result = new Rectangle();
}
result.west = Math.min(rectangle.west, cartographic.longitude);
result.south = Math.min(rectangle.south, cartographic.latitude);
result.east = Math.max(rectangle.east, cartographic.longitude);
result.north = Math.max(rectangle.north, cartographic.latitude);
return result;
};
/**
* Returns true if the cartographic is on or inside the rectangle, false otherwise.
*
* @param {Rectangle} rectangle The rectangle
* @param {Cartographic} cartographic The cartographic to test.
* @returns {Boolean} true if the provided cartographic is inside the rectangle, false otherwise.
*/
Rectangle.contains = function(rectangle, cartographic) {
Check.typeOf.object('rectangle', rectangle);
Check.typeOf.object('cartographic', cartographic);
var longitude = cartographic.longitude;
var latitude = cartographic.latitude;
var west = rectangle.west;
var east = rectangle.east;
if (east < west) {
east += CesiumMath.TWO_PI;
if (longitude < 0.0) {
longitude += CesiumMath.TWO_PI;
}
}
return (longitude > west || CesiumMath.equalsEpsilon(longitude, west, CesiumMath.EPSILON14)) &&
(longitude < east || CesiumMath.equalsEpsilon(longitude, east, CesiumMath.EPSILON14)) &&
latitude >= rectangle.south &&
latitude <= rectangle.north;
};
var subsampleLlaScratch = new Cartographic();
/**
* Samples a rectangle so that it includes a list of Cartesian points suitable for passing to
* {@link BoundingSphere#fromPoints}. Sampling is necessary to account
* for rectangles that cover the poles or cross the equator.
*
* @param {Rectangle} rectangle The rectangle to subsample.
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid to use.
* @param {Number} [surfaceHeight=0.0] The height of the rectangle above the ellipsoid.
* @param {Cartesian3[]} [result] The array of Cartesians onto which to store the result.
* @returns {Cartesian3[]} The modified result parameter or a new Array of Cartesians instances if none was provided.
*/
Rectangle.subsample = function(rectangle, ellipsoid, surfaceHeight, result) {
Check.typeOf.object('rectangle', rectangle);
ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
surfaceHeight = defaultValue(surfaceHeight, 0.0);
if (!defined(result)) {
result = [];
}
var length = 0;
var north = rectangle.north;
var south = rectangle.south;
var east = rectangle.east;
var west = rectangle.west;
var lla = subsampleLlaScratch;
lla.height = surfaceHeight;
lla.longitude = west;
lla.latitude = north;
result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
length++;
lla.longitude = east;
result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
length++;
lla.latitude = south;
result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
length++;
lla.longitude = west;
result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
length++;
if (north < 0.0) {
lla.latitude = north;
} else if (south > 0.0) {
lla.latitude = south;
} else {
lla.latitude = 0.0;
}
for ( var i = 1; i < 8; ++i) {
lla.longitude = -Math.PI + i * CesiumMath.PI_OVER_TWO;
if (Rectangle.contains(rectangle, lla)) {
result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
length++;
}
}
if (lla.latitude === 0.0) {
lla.longitude = west;
result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
length++;
lla.longitude = east;
result[length] = ellipsoid.cartographicToCartesian(lla, result[length]);
length++;
}
result.length = length;
return result;
};
/**
* The largest possible rectangle.
*
* @type {Rectangle}
* @constant
*/
Rectangle.MAX_VALUE = freezeObject(new Rectangle(-Math.PI, -CesiumMath.PI_OVER_TWO, Math.PI, CesiumMath.PI_OVER_TWO));
return Rectangle;
});
/*global define*/
define('Core/BoundingSphere',[
'./Cartesian3',
'./Cartographic',
'./Check',
'./defaultValue',
'./defined',
'./Ellipsoid',
'./GeographicProjection',
'./Intersect',
'./Interval',
'./Matrix3',
'./Matrix4',
'./Rectangle'
], function(
Cartesian3,
Cartographic,
Check,
defaultValue,
defined,
Ellipsoid,
GeographicProjection,
Intersect,
Interval,
Matrix3,
Matrix4,
Rectangle) {
'use strict';
/**
* A bounding sphere with a center and a radius.
* @alias BoundingSphere
* @constructor
*
* @param {Cartesian3} [center=Cartesian3.ZERO] The center of the bounding sphere.
* @param {Number} [radius=0.0] The radius of the bounding sphere.
*
* @see AxisAlignedBoundingBox
* @see BoundingRectangle
* @see Packable
*/
function BoundingSphere(center, radius) {
/**
* The center point of the sphere.
* @type {Cartesian3}
* @default {@link Cartesian3.ZERO}
*/
this.center = Cartesian3.clone(defaultValue(center, Cartesian3.ZERO));
/**
* The radius of the sphere.
* @type {Number}
* @default 0.0
*/
this.radius = defaultValue(radius, 0.0);
}
var fromPointsXMin = new Cartesian3();
var fromPointsYMin = new Cartesian3();
var fromPointsZMin = new Cartesian3();
var fromPointsXMax = new Cartesian3();
var fromPointsYMax = new Cartesian3();
var fromPointsZMax = new Cartesian3();
var fromPointsCurrentPos = new Cartesian3();
var fromPointsScratch = new Cartesian3();
var fromPointsRitterCenter = new Cartesian3();
var fromPointsMinBoxPt = new Cartesian3();
var fromPointsMaxBoxPt = new Cartesian3();
var fromPointsNaiveCenterScratch = new Cartesian3();
/**
* Computes a tight-fitting bounding sphere enclosing a list of 3D Cartesian points.
* The bounding sphere is computed by running two algorithms, a naive algorithm and
* Ritter's algorithm. The smaller of the two spheres is used to ensure a tight fit.
*
* @param {Cartesian3[]} positions An array of points that the bounding sphere will enclose. Each point must have <code>x</code>, <code>y</code>, and <code>z</code> properties.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if one was not provided.
*
* @see {@link http://blogs.agi.com/insight3d/index.php/2008/02/04/a-bounding/|Bounding Sphere computation article}
*/
BoundingSphere.fromPoints = function(positions, result) {
if (!defined(result)) {
result = new BoundingSphere();
}
if (!defined(positions) || positions.length === 0) {
result.center = Cartesian3.clone(Cartesian3.ZERO, result.center);
result.radius = 0.0;
return result;
}
var currentPos = Cartesian3.clone(positions[0], fromPointsCurrentPos);
var xMin = Cartesian3.clone(currentPos, fromPointsXMin);
var yMin = Cartesian3.clone(currentPos, fromPointsYMin);
var zMin = Cartesian3.clone(currentPos, fromPointsZMin);
var xMax = Cartesian3.clone(currentPos, fromPointsXMax);
var yMax = Cartesian3.clone(currentPos, fromPointsYMax);
var zMax = Cartesian3.clone(currentPos, fromPointsZMax);
var numPositions = positions.length;
for (var i = 1; i < numPositions; i++) {
Cartesian3.clone(positions[i], currentPos);
var x = currentPos.x;
var y = currentPos.y;
var z = currentPos.z;
// Store points containing the the smallest and largest components
if (x < xMin.x) {
Cartesian3.clone(currentPos, xMin);
}
if (x > xMax.x) {
Cartesian3.clone(currentPos, xMax);
}
if (y < yMin.y) {
Cartesian3.clone(currentPos, yMin);
}
if (y > yMax.y) {
Cartesian3.clone(currentPos, yMax);
}
if (z < zMin.z) {
Cartesian3.clone(currentPos, zMin);
}
if (z > zMax.z) {
Cartesian3.clone(currentPos, zMax);
}
}
// Compute x-, y-, and z-spans (Squared distances b/n each component's min. and max.).
var xSpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(xMax, xMin, fromPointsScratch));
var ySpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(yMax, yMin, fromPointsScratch));
var zSpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(zMax, zMin, fromPointsScratch));
// Set the diameter endpoints to the largest span.
var diameter1 = xMin;
var diameter2 = xMax;
var maxSpan = xSpan;
if (ySpan > maxSpan) {
maxSpan = ySpan;
diameter1 = yMin;
diameter2 = yMax;
}
if (zSpan > maxSpan) {
maxSpan = zSpan;
diameter1 = zMin;
diameter2 = zMax;
}
// Calculate the center of the initial sphere found by Ritter's algorithm
var ritterCenter = fromPointsRitterCenter;
ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
// Calculate the radius of the initial sphere found by Ritter's algorithm
var radiusSquared = Cartesian3.magnitudeSquared(Cartesian3.subtract(diameter2, ritterCenter, fromPointsScratch));
var ritterRadius = Math.sqrt(radiusSquared);
// Find the center of the sphere found using the Naive method.
var minBoxPt = fromPointsMinBoxPt;
minBoxPt.x = xMin.x;
minBoxPt.y = yMin.y;
minBoxPt.z = zMin.z;
var maxBoxPt = fromPointsMaxBoxPt;
maxBoxPt.x = xMax.x;
maxBoxPt.y = yMax.y;
maxBoxPt.z = zMax.z;
var naiveCenter = Cartesian3.multiplyByScalar(Cartesian3.add(minBoxPt, maxBoxPt, fromPointsScratch), 0.5, fromPointsNaiveCenterScratch);
// Begin 2nd pass to find naive radius and modify the ritter sphere.
var naiveRadius = 0;
for (i = 0; i < numPositions; i++) {
Cartesian3.clone(positions[i], currentPos);
// Find the furthest point from the naive center to calculate the naive radius.
var r = Cartesian3.magnitude(Cartesian3.subtract(currentPos, naiveCenter, fromPointsScratch));
if (r > naiveRadius) {
naiveRadius = r;
}
// Make adjustments to the Ritter Sphere to include all points.
var oldCenterToPointSquared = Cartesian3.magnitudeSquared(Cartesian3.subtract(currentPos, ritterCenter, fromPointsScratch));
if (oldCenterToPointSquared > radiusSquared) {
var oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
// Calculate new radius to include the point that lies outside
ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
radiusSquared = ritterRadius * ritterRadius;
// Calculate center of new Ritter sphere
var oldToNew = oldCenterToPoint - ritterRadius;
ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;
ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;
ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;
}
}
if (ritterRadius < naiveRadius) {
Cartesian3.clone(ritterCenter, result.center);
result.radius = ritterRadius;
} else {
Cartesian3.clone(naiveCenter, result.center);
result.radius = naiveRadius;
}
return result;
};
var defaultProjection = new GeographicProjection();
var fromRectangle2DLowerLeft = new Cartesian3();
var fromRectangle2DUpperRight = new Cartesian3();
var fromRectangle2DSouthwest = new Cartographic();
var fromRectangle2DNortheast = new Cartographic();
/**
* Computes a bounding sphere from an rectangle projected in 2D.
*
* @param {Rectangle} rectangle The rectangle around which to create a bounding sphere.
* @param {Object} [projection=GeographicProjection] The projection used to project the rectangle into 2D.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.fromRectangle2D = function(rectangle, projection, result) {
return BoundingSphere.fromRectangleWithHeights2D(rectangle, projection, 0.0, 0.0, result);
};
/**
* Computes a bounding sphere from a rectangle projected in 2D. The bounding sphere accounts for the
* object's minimum and maximum heights over the rectangle.
*
* @param {Rectangle} rectangle The rectangle around which to create a bounding sphere.
* @param {Object} [projection=GeographicProjection] The projection used to project the rectangle into 2D.
* @param {Number} [minimumHeight=0.0] The minimum height over the rectangle.
* @param {Number} [maximumHeight=0.0] The maximum height over the rectangle.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.fromRectangleWithHeights2D = function(rectangle, projection, minimumHeight, maximumHeight, result) {
if (!defined(result)) {
result = new BoundingSphere();
}
if (!defined(rectangle)) {
result.center = Cartesian3.clone(Cartesian3.ZERO, result.center);
result.radius = 0.0;
return result;
}
projection = defaultValue(projection, defaultProjection);
Rectangle.southwest(rectangle, fromRectangle2DSouthwest);
fromRectangle2DSouthwest.height = minimumHeight;
Rectangle.northeast(rectangle, fromRectangle2DNortheast);
fromRectangle2DNortheast.height = maximumHeight;
var lowerLeft = projection.project(fromRectangle2DSouthwest, fromRectangle2DLowerLeft);
var upperRight = projection.project(fromRectangle2DNortheast, fromRectangle2DUpperRight);
var width = upperRight.x - lowerLeft.x;
var height = upperRight.y - lowerLeft.y;
var elevation = upperRight.z - lowerLeft.z;
result.radius = Math.sqrt(width * width + height * height + elevation * elevation) * 0.5;
var center = result.center;
center.x = lowerLeft.x + width * 0.5;
center.y = lowerLeft.y + height * 0.5;
center.z = lowerLeft.z + elevation * 0.5;
return result;
};
var fromRectangle3DScratch = [];
/**
* Computes a bounding sphere from a rectangle in 3D. The bounding sphere is created using a subsample of points
* on the ellipsoid and contained in the rectangle. It may not be accurate for all rectangles on all types of ellipsoids.
*
* @param {Rectangle} rectangle The valid rectangle used to create a bounding sphere.
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid used to determine positions of the rectangle.
* @param {Number} [surfaceHeight=0.0] The height above the surface of the ellipsoid.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.fromRectangle3D = function(rectangle, ellipsoid, surfaceHeight, result) {
ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
surfaceHeight = defaultValue(surfaceHeight, 0.0);
var positions;
if (defined(rectangle)) {
positions = Rectangle.subsample(rectangle, ellipsoid, surfaceHeight, fromRectangle3DScratch);
}
return BoundingSphere.fromPoints(positions, result);
};
/**
* Computes a tight-fitting bounding sphere enclosing a list of 3D points, where the points are
* stored in a flat array in X, Y, Z, order. The bounding sphere is computed by running two
* algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to
* ensure a tight fit.
*
* @param {Number[]} positions An array of points that the bounding sphere will enclose. Each point
* is formed from three elements in the array in the order X, Y, Z.
* @param {Cartesian3} [center=Cartesian3.ZERO] The position to which the positions are relative, which need not be the
* origin of the coordinate system. This is useful when the positions are to be used for
* relative-to-center (RTC) rendering.
* @param {Number} [stride=3] The number of array elements per vertex. It must be at least 3, but it may
* be higher. Regardless of the value of this parameter, the X coordinate of the first position
* is at array index 0, the Y coordinate is at array index 1, and the Z coordinate is at array index
* 2. When stride is 3, the X coordinate of the next position then begins at array index 3. If
* the stride is 5, however, two array elements are skipped and the next position begins at array
* index 5.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if one was not provided.
*
* @example
* // Compute the bounding sphere from 3 positions, each specified relative to a center.
* // In addition to the X, Y, and Z coordinates, the points array contains two additional
* // elements per point which are ignored for the purpose of computing the bounding sphere.
* var center = new Cesium.Cartesian3(1.0, 2.0, 3.0);
* var points = [1.0, 2.0, 3.0, 0.1, 0.2,
* 4.0, 5.0, 6.0, 0.1, 0.2,
* 7.0, 8.0, 9.0, 0.1, 0.2];
* var sphere = Cesium.BoundingSphere.fromVertices(points, center, 5);
*
* @see {@link http://blogs.agi.com/insight3d/index.php/2008/02/04/a-bounding/|Bounding Sphere computation article}
*/
BoundingSphere.fromVertices = function(positions, center, stride, result) {
if (!defined(result)) {
result = new BoundingSphere();
}
if (!defined(positions) || positions.length === 0) {
result.center = Cartesian3.clone(Cartesian3.ZERO, result.center);
result.radius = 0.0;
return result;
}
center = defaultValue(center, Cartesian3.ZERO);
stride = defaultValue(stride, 3);
Check.typeOf.number.greaterThanOrEquals('stride', stride, 3);
var currentPos = fromPointsCurrentPos;
currentPos.x = positions[0] + center.x;
currentPos.y = positions[1] + center.y;
currentPos.z = positions[2] + center.z;
var xMin = Cartesian3.clone(currentPos, fromPointsXMin);
var yMin = Cartesian3.clone(currentPos, fromPointsYMin);
var zMin = Cartesian3.clone(currentPos, fromPointsZMin);
var xMax = Cartesian3.clone(currentPos, fromPointsXMax);
var yMax = Cartesian3.clone(currentPos, fromPointsYMax);
var zMax = Cartesian3.clone(currentPos, fromPointsZMax);
var numElements = positions.length;
for (var i = 0; i < numElements; i += stride) {
var x = positions[i] + center.x;
var y = positions[i + 1] + center.y;
var z = positions[i + 2] + center.z;
currentPos.x = x;
currentPos.y = y;
currentPos.z = z;
// Store points containing the the smallest and largest components
if (x < xMin.x) {
Cartesian3.clone(currentPos, xMin);
}
if (x > xMax.x) {
Cartesian3.clone(currentPos, xMax);
}
if (y < yMin.y) {
Cartesian3.clone(currentPos, yMin);
}
if (y > yMax.y) {
Cartesian3.clone(currentPos, yMax);
}
if (z < zMin.z) {
Cartesian3.clone(currentPos, zMin);
}
if (z > zMax.z) {
Cartesian3.clone(currentPos, zMax);
}
}
// Compute x-, y-, and z-spans (Squared distances b/n each component's min. and max.).
var xSpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(xMax, xMin, fromPointsScratch));
var ySpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(yMax, yMin, fromPointsScratch));
var zSpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(zMax, zMin, fromPointsScratch));
// Set the diameter endpoints to the largest span.
var diameter1 = xMin;
var diameter2 = xMax;
var maxSpan = xSpan;
if (ySpan > maxSpan) {
maxSpan = ySpan;
diameter1 = yMin;
diameter2 = yMax;
}
if (zSpan > maxSpan) {
maxSpan = zSpan;
diameter1 = zMin;
diameter2 = zMax;
}
// Calculate the center of the initial sphere found by Ritter's algorithm
var ritterCenter = fromPointsRitterCenter;
ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
// Calculate the radius of the initial sphere found by Ritter's algorithm
var radiusSquared = Cartesian3.magnitudeSquared(Cartesian3.subtract(diameter2, ritterCenter, fromPointsScratch));
var ritterRadius = Math.sqrt(radiusSquared);
// Find the center of the sphere found using the Naive method.
var minBoxPt = fromPointsMinBoxPt;
minBoxPt.x = xMin.x;
minBoxPt.y = yMin.y;
minBoxPt.z = zMin.z;
var maxBoxPt = fromPointsMaxBoxPt;
maxBoxPt.x = xMax.x;
maxBoxPt.y = yMax.y;
maxBoxPt.z = zMax.z;
var naiveCenter = Cartesian3.multiplyByScalar(Cartesian3.add(minBoxPt, maxBoxPt, fromPointsScratch), 0.5, fromPointsNaiveCenterScratch);
// Begin 2nd pass to find naive radius and modify the ritter sphere.
var naiveRadius = 0;
for (i = 0; i < numElements; i += stride) {
currentPos.x = positions[i] + center.x;
currentPos.y = positions[i + 1] + center.y;
currentPos.z = positions[i + 2] + center.z;
// Find the furthest point from the naive center to calculate the naive radius.
var r = Cartesian3.magnitude(Cartesian3.subtract(currentPos, naiveCenter, fromPointsScratch));
if (r > naiveRadius) {
naiveRadius = r;
}
// Make adjustments to the Ritter Sphere to include all points.
var oldCenterToPointSquared = Cartesian3.magnitudeSquared(Cartesian3.subtract(currentPos, ritterCenter, fromPointsScratch));
if (oldCenterToPointSquared > radiusSquared) {
var oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
// Calculate new radius to include the point that lies outside
ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
radiusSquared = ritterRadius * ritterRadius;
// Calculate center of new Ritter sphere
var oldToNew = oldCenterToPoint - ritterRadius;
ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;
ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;
ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;
}
}
if (ritterRadius < naiveRadius) {
Cartesian3.clone(ritterCenter, result.center);
result.radius = ritterRadius;
} else {
Cartesian3.clone(naiveCenter, result.center);
result.radius = naiveRadius;
}
return result;
};
/**
* Computes a tight-fitting bounding sphere enclosing a list of {@link EncodedCartesian3}s, where the points are
* stored in parallel flat arrays in X, Y, Z, order. The bounding sphere is computed by running two
* algorithms, a naive algorithm and Ritter's algorithm. The smaller of the two spheres is used to
* ensure a tight fit.
*
* @param {Number[]} positionsHigh An array of high bits of the encoded cartesians that the bounding sphere will enclose. Each point
* is formed from three elements in the array in the order X, Y, Z.
* @param {Number[]} positionsLow An array of low bits of the encoded cartesians that the bounding sphere will enclose. Each point
* is formed from three elements in the array in the order X, Y, Z.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if one was not provided.
*
* @see {@link http://blogs.agi.com/insight3d/index.php/2008/02/04/a-bounding/|Bounding Sphere computation article}
*/
BoundingSphere.fromEncodedCartesianVertices = function(positionsHigh, positionsLow, result) {
if (!defined(result)) {
result = new BoundingSphere();
}
if (!defined(positionsHigh) || !defined(positionsLow) || positionsHigh.length !== positionsLow.length || positionsHigh.length === 0) {
result.center = Cartesian3.clone(Cartesian3.ZERO, result.center);
result.radius = 0.0;
return result;
}
var currentPos = fromPointsCurrentPos;
currentPos.x = positionsHigh[0] + positionsLow[0];
currentPos.y = positionsHigh[1] + positionsLow[1];
currentPos.z = positionsHigh[2] + positionsLow[2];
var xMin = Cartesian3.clone(currentPos, fromPointsXMin);
var yMin = Cartesian3.clone(currentPos, fromPointsYMin);
var zMin = Cartesian3.clone(currentPos, fromPointsZMin);
var xMax = Cartesian3.clone(currentPos, fromPointsXMax);
var yMax = Cartesian3.clone(currentPos, fromPointsYMax);
var zMax = Cartesian3.clone(currentPos, fromPointsZMax);
var numElements = positionsHigh.length;
for (var i = 0; i < numElements; i += 3) {
var x = positionsHigh[i] + positionsLow[i];
var y = positionsHigh[i + 1] + positionsLow[i + 1];
var z = positionsHigh[i + 2] + positionsLow[i + 2];
currentPos.x = x;
currentPos.y = y;
currentPos.z = z;
// Store points containing the the smallest and largest components
if (x < xMin.x) {
Cartesian3.clone(currentPos, xMin);
}
if (x > xMax.x) {
Cartesian3.clone(currentPos, xMax);
}
if (y < yMin.y) {
Cartesian3.clone(currentPos, yMin);
}
if (y > yMax.y) {
Cartesian3.clone(currentPos, yMax);
}
if (z < zMin.z) {
Cartesian3.clone(currentPos, zMin);
}
if (z > zMax.z) {
Cartesian3.clone(currentPos, zMax);
}
}
// Compute x-, y-, and z-spans (Squared distances b/n each component's min. and max.).
var xSpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(xMax, xMin, fromPointsScratch));
var ySpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(yMax, yMin, fromPointsScratch));
var zSpan = Cartesian3.magnitudeSquared(Cartesian3.subtract(zMax, zMin, fromPointsScratch));
// Set the diameter endpoints to the largest span.
var diameter1 = xMin;
var diameter2 = xMax;
var maxSpan = xSpan;
if (ySpan > maxSpan) {
maxSpan = ySpan;
diameter1 = yMin;
diameter2 = yMax;
}
if (zSpan > maxSpan) {
maxSpan = zSpan;
diameter1 = zMin;
diameter2 = zMax;
}
// Calculate the center of the initial sphere found by Ritter's algorithm
var ritterCenter = fromPointsRitterCenter;
ritterCenter.x = (diameter1.x + diameter2.x) * 0.5;
ritterCenter.y = (diameter1.y + diameter2.y) * 0.5;
ritterCenter.z = (diameter1.z + diameter2.z) * 0.5;
// Calculate the radius of the initial sphere found by Ritter's algorithm
var radiusSquared = Cartesian3.magnitudeSquared(Cartesian3.subtract(diameter2, ritterCenter, fromPointsScratch));
var ritterRadius = Math.sqrt(radiusSquared);
// Find the center of the sphere found using the Naive method.
var minBoxPt = fromPointsMinBoxPt;
minBoxPt.x = xMin.x;
minBoxPt.y = yMin.y;
minBoxPt.z = zMin.z;
var maxBoxPt = fromPointsMaxBoxPt;
maxBoxPt.x = xMax.x;
maxBoxPt.y = yMax.y;
maxBoxPt.z = zMax.z;
var naiveCenter = Cartesian3.multiplyByScalar(Cartesian3.add(minBoxPt, maxBoxPt, fromPointsScratch), 0.5, fromPointsNaiveCenterScratch);
// Begin 2nd pass to find naive radius and modify the ritter sphere.
var naiveRadius = 0;
for (i = 0; i < numElements; i += 3) {
currentPos.x = positionsHigh[i] + positionsLow[i];
currentPos.y = positionsHigh[i + 1] + positionsLow[i + 1];
currentPos.z = positionsHigh[i + 2] + positionsLow[i + 2];
// Find the furthest point from the naive center to calculate the naive radius.
var r = Cartesian3.magnitude(Cartesian3.subtract(currentPos, naiveCenter, fromPointsScratch));
if (r > naiveRadius) {
naiveRadius = r;
}
// Make adjustments to the Ritter Sphere to include all points.
var oldCenterToPointSquared = Cartesian3.magnitudeSquared(Cartesian3.subtract(currentPos, ritterCenter, fromPointsScratch));
if (oldCenterToPointSquared > radiusSquared) {
var oldCenterToPoint = Math.sqrt(oldCenterToPointSquared);
// Calculate new radius to include the point that lies outside
ritterRadius = (ritterRadius + oldCenterToPoint) * 0.5;
radiusSquared = ritterRadius * ritterRadius;
// Calculate center of new Ritter sphere
var oldToNew = oldCenterToPoint - ritterRadius;
ritterCenter.x = (ritterRadius * ritterCenter.x + oldToNew * currentPos.x) / oldCenterToPoint;
ritterCenter.y = (ritterRadius * ritterCenter.y + oldToNew * currentPos.y) / oldCenterToPoint;
ritterCenter.z = (ritterRadius * ritterCenter.z + oldToNew * currentPos.z) / oldCenterToPoint;
}
}
if (ritterRadius < naiveRadius) {
Cartesian3.clone(ritterCenter, result.center);
result.radius = ritterRadius;
} else {
Cartesian3.clone(naiveCenter, result.center);
result.radius = naiveRadius;
}
return result;
};
/**
* Computes a bounding sphere from the corner points of an axis-aligned bounding box. The sphere
* tighly and fully encompases the box.
*
* @param {Cartesian3} [corner] The minimum height over the rectangle.
* @param {Cartesian3} [oppositeCorner] The maximum height over the rectangle.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*
* @example
* // Create a bounding sphere around the unit cube
* var sphere = Cesium.BoundingSphere.fromCornerPoints(new Cesium.Cartesian3(-0.5, -0.5, -0.5), new Cesium.Cartesian3(0.5, 0.5, 0.5));
*/
BoundingSphere.fromCornerPoints = function(corner, oppositeCorner, result) {
Check.typeOf.object('corner', corner);
Check.typeOf.object('oppositeCorner', oppositeCorner);
if (!defined(result)) {
result = new BoundingSphere();
}
var center = result.center;
Cartesian3.add(corner, oppositeCorner, center);
Cartesian3.multiplyByScalar(center, 0.5, center);
result.radius = Cartesian3.distance(center, oppositeCorner);
return result;
};
/**
* Creates a bounding sphere encompassing an ellipsoid.
*
* @param {Ellipsoid} ellipsoid The ellipsoid around which to create a bounding sphere.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*
* @example
* var boundingSphere = Cesium.BoundingSphere.fromEllipsoid(ellipsoid);
*/
BoundingSphere.fromEllipsoid = function(ellipsoid, result) {
Check.typeOf.object('ellipsoid', ellipsoid);
if (!defined(result)) {
result = new BoundingSphere();
}
Cartesian3.clone(Cartesian3.ZERO, result.center);
result.radius = ellipsoid.maximumRadius;
return result;
};
var fromBoundingSpheresScratch = new Cartesian3();
/**
* Computes a tight-fitting bounding sphere enclosing the provided array of bounding spheres.
*
* @param {BoundingSphere[]} boundingSpheres The array of bounding spheres.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.fromBoundingSpheres = function(boundingSpheres, result) {
if (!defined(result)) {
result = new BoundingSphere();
}
if (!defined(boundingSpheres) || boundingSpheres.length === 0) {
result.center = Cartesian3.clone(Cartesian3.ZERO, result.center);
result.radius = 0.0;
return result;
}
var length = boundingSpheres.length;
if (length === 1) {
return BoundingSphere.clone(boundingSpheres[0], result);
}
if (length === 2) {
return BoundingSphere.union(boundingSpheres[0], boundingSpheres[1], result);
}
var positions = [];
for (var i = 0; i < length; i++) {
positions.push(boundingSpheres[i].center);
}
result = BoundingSphere.fromPoints(positions, result);
var center = result.center;
var radius = result.radius;
for (i = 0; i < length; i++) {
var tmp = boundingSpheres[i];
radius = Math.max(radius, Cartesian3.distance(center, tmp.center, fromBoundingSpheresScratch) + tmp.radius);
}
result.radius = radius;
return result;
};
var fromOrientedBoundingBoxScratchU = new Cartesian3();
var fromOrientedBoundingBoxScratchV = new Cartesian3();
var fromOrientedBoundingBoxScratchW = new Cartesian3();
/**
* Computes a tight-fitting bounding sphere enclosing the provided oriented bounding box.
*
* @param {OrientedBoundingBox} orientedBoundingBox The oriented bounding box.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.fromOrientedBoundingBox = function(orientedBoundingBox, result) {
if (!defined(result)) {
result = new BoundingSphere();
}
var halfAxes = orientedBoundingBox.halfAxes;
var u = Matrix3.getColumn(halfAxes, 0, fromOrientedBoundingBoxScratchU);
var v = Matrix3.getColumn(halfAxes, 1, fromOrientedBoundingBoxScratchV);
var w = Matrix3.getColumn(halfAxes, 2, fromOrientedBoundingBoxScratchW);
var uHalf = Cartesian3.magnitude(u);
var vHalf = Cartesian3.magnitude(v);
var wHalf = Cartesian3.magnitude(w);
result.center = Cartesian3.clone(orientedBoundingBox.center, result.center);
result.radius = Math.max(uHalf, vHalf, wHalf);
return result;
};
/**
* Duplicates a BoundingSphere instance.
*
* @param {BoundingSphere} sphere The bounding sphere to duplicate.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided. (Returns undefined if sphere is undefined)
*/
BoundingSphere.clone = function(sphere, result) {
if (!defined(sphere)) {
return undefined;
}
if (!defined(result)) {
return new BoundingSphere(sphere.center, sphere.radius);
}
result.center = Cartesian3.clone(sphere.center, result.center);
result.radius = sphere.radius;
return result;
};
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
BoundingSphere.packedLength = 4;
/**
* Stores the provided instance into the provided array.
*
* @param {BoundingSphere} 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
*/
BoundingSphere.pack = function(value, array, startingIndex) {
Check.typeOf.object('value', value);
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
var center = value.center;
array[startingIndex++] = center.x;
array[startingIndex++] = center.y;
array[startingIndex++] = center.z;
array[startingIndex] = value.radius;
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 {BoundingSphere} [result] The object into which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if one was not provided.
*/
BoundingSphere.unpack = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new BoundingSphere();
}
var center = result.center;
center.x = array[startingIndex++];
center.y = array[startingIndex++];
center.z = array[startingIndex++];
result.radius = array[startingIndex];
return result;
};
var unionScratch = new Cartesian3();
var unionScratchCenter = new Cartesian3();
/**
* Computes a bounding sphere that contains both the left and right bounding spheres.
*
* @param {BoundingSphere} left A sphere to enclose in a bounding sphere.
* @param {BoundingSphere} right A sphere to enclose in a bounding sphere.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.union = function(left, right, result) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
if (!defined(result)) {
result = new BoundingSphere();
}
var leftCenter = left.center;
var leftRadius = left.radius;
var rightCenter = right.center;
var rightRadius = right.radius;
var toRightCenter = Cartesian3.subtract(rightCenter, leftCenter, unionScratch);
var centerSeparation = Cartesian3.magnitude(toRightCenter);
if (leftRadius >= (centerSeparation + rightRadius)) {
// Left sphere wins.
left.clone(result);
return result;
}
if (rightRadius >= (centerSeparation + leftRadius)) {
// Right sphere wins.
right.clone(result);
return result;
}
// There are two tangent points, one on far side of each sphere.
var halfDistanceBetweenTangentPoints = (leftRadius + centerSeparation + rightRadius) * 0.5;
// Compute the center point halfway between the two tangent points.
var center = Cartesian3.multiplyByScalar(toRightCenter,
(-leftRadius + halfDistanceBetweenTangentPoints) / centerSeparation, unionScratchCenter);
Cartesian3.add(center, leftCenter, center);
Cartesian3.clone(center, result.center);
result.radius = halfDistanceBetweenTangentPoints;
return result;
};
var expandScratch = new Cartesian3();
/**
* Computes a bounding sphere by enlarging the provided sphere to contain the provided point.
*
* @param {BoundingSphere} sphere A sphere to expand.
* @param {Cartesian3} point A point to enclose in a bounding sphere.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.expand = function(sphere, point, result) {
Check.typeOf.object('sphere', sphere);
Check.typeOf.object('point', point);
result = BoundingSphere.clone(sphere, result);
var radius = Cartesian3.magnitude(Cartesian3.subtract(point, result.center, expandScratch));
if (radius > result.radius) {
result.radius = radius;
}
return result;
};
/**
* Determines which side of a plane a sphere is located.
*
* @param {BoundingSphere} sphere The bounding sphere to test.
* @param {Plane} plane The plane to test against.
* @returns {Intersect} {@link Intersect.INSIDE} if the entire sphere is on the side of the plane
* the normal is pointing, {@link Intersect.OUTSIDE} if the entire sphere is
* on the opposite side, and {@link Intersect.INTERSECTING} if the sphere
* intersects the plane.
*/
BoundingSphere.intersectPlane = function(sphere, plane) {
Check.typeOf.object('sphere', sphere);
Check.typeOf.object('plane', plane);
var center = sphere.center;
var radius = sphere.radius;
var normal = plane.normal;
var distanceToPlane = Cartesian3.dot(normal, center) + plane.distance;
if (distanceToPlane < -radius) {
// The center point is negative side of the plane normal
return Intersect.OUTSIDE;
} else if (distanceToPlane < radius) {
// The center point is positive side of the plane, but radius extends beyond it; partial overlap
return Intersect.INTERSECTING;
}
return Intersect.INSIDE;
};
/**
* Applies a 4x4 affine transformation matrix to a bounding sphere.
*
* @param {BoundingSphere} sphere The bounding sphere to apply the transformation to.
* @param {Matrix4} transform The transformation matrix to apply to the bounding sphere.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.transform = function(sphere, transform, result) {
Check.typeOf.object('sphere', sphere);
Check.typeOf.object('transform', transform);
if (!defined(result)) {
result = new BoundingSphere();
}
result.center = Matrix4.multiplyByPoint(transform, sphere.center, result.center);
result.radius = Matrix4.getMaximumScale(transform) * sphere.radius;
return result;
};
var distanceSquaredToScratch = new Cartesian3();
/**
* Computes the estimated distance squared from the closest point on a bounding sphere to a point.
*
* @param {BoundingSphere} sphere The sphere.
* @param {Cartesian3} cartesian The point
* @returns {Number} The estimated distance squared from the bounding sphere to the point.
*
* @example
* // Sort bounding spheres from back to front
* spheres.sort(function(a, b) {
* return Cesium.BoundingSphere.distanceSquaredTo(b, camera.positionWC) - Cesium.BoundingSphere.distanceSquaredTo(a, camera.positionWC);
* });
*/
BoundingSphere.distanceSquaredTo = function(sphere, cartesian) {
Check.typeOf.object('sphere', sphere);
Check.typeOf.object('cartesian', cartesian);
var diff = Cartesian3.subtract(sphere.center, cartesian, distanceSquaredToScratch);
return Cartesian3.magnitudeSquared(diff) - sphere.radius * sphere.radius;
};
/**
* Applies a 4x4 affine transformation matrix to a bounding sphere where there is no scale
* The transformation matrix is not verified to have a uniform scale of 1.
* This method is faster than computing the general bounding sphere transform using {@link BoundingSphere.transform}.
*
* @param {BoundingSphere} sphere The bounding sphere to apply the transformation to.
* @param {Matrix4} transform The transformation matrix to apply to the bounding sphere.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*
* @example
* var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(positionOnEllipsoid);
* var boundingSphere = new Cesium.BoundingSphere();
* var newBoundingSphere = Cesium.BoundingSphere.transformWithoutScale(boundingSphere, modelMatrix);
*/
BoundingSphere.transformWithoutScale = function(sphere, transform, result) {
Check.typeOf.object('sphere', sphere);
Check.typeOf.object('transform', transform);
if (!defined(result)) {
result = new BoundingSphere();
}
result.center = Matrix4.multiplyByPoint(transform, sphere.center, result.center);
result.radius = sphere.radius;
return result;
};
var scratchCartesian3 = new Cartesian3();
/**
* The distances calculated by the vector from the center of the bounding sphere to position projected onto direction
* plus/minus the radius of the bounding sphere.
* <br>
* If you imagine the infinite number of planes with normal direction, this computes the smallest distance to the
* closest and farthest planes from position that intersect the bounding sphere.
*
* @param {BoundingSphere} sphere The bounding sphere to calculate the distance to.
* @param {Cartesian3} position The position to calculate the distance from.
* @param {Cartesian3} direction The direction from position.
* @param {Interval} [result] A Interval to store the nearest and farthest distances.
* @returns {Interval} The nearest and farthest distances on the bounding sphere from position in direction.
*/
BoundingSphere.computePlaneDistances = function(sphere, position, direction, result) {
Check.typeOf.object('sphere', sphere);
Check.typeOf.object('position', position);
Check.typeOf.object('direction', direction);
if (!defined(result)) {
result = new Interval();
}
var toCenter = Cartesian3.subtract(sphere.center, position, scratchCartesian3);
var mag = Cartesian3.dot(direction, toCenter);
result.start = mag - sphere.radius;
result.stop = mag + sphere.radius;
return result;
};
var projectTo2DNormalScratch = new Cartesian3();
var projectTo2DEastScratch = new Cartesian3();
var projectTo2DNorthScratch = new Cartesian3();
var projectTo2DWestScratch = new Cartesian3();
var projectTo2DSouthScratch = new Cartesian3();
var projectTo2DCartographicScratch = new Cartographic();
var projectTo2DPositionsScratch = new Array(8);
for (var n = 0; n < 8; ++n) {
projectTo2DPositionsScratch[n] = new Cartesian3();
}
var projectTo2DProjection = new GeographicProjection();
/**
* Creates a bounding sphere in 2D from a bounding sphere in 3D world coordinates.
*
* @param {BoundingSphere} sphere The bounding sphere to transform to 2D.
* @param {Object} [projection=GeographicProjection] The projection to 2D.
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.projectTo2D = function(sphere, projection, result) {
Check.typeOf.object('sphere', sphere);
projection = defaultValue(projection, projectTo2DProjection);
var ellipsoid = projection.ellipsoid;
var center = sphere.center;
var radius = sphere.radius;
var normal = ellipsoid.geodeticSurfaceNormal(center, projectTo2DNormalScratch);
var east = Cartesian3.cross(Cartesian3.UNIT_Z, normal, projectTo2DEastScratch);
Cartesian3.normalize(east, east);
var north = Cartesian3.cross(normal, east, projectTo2DNorthScratch);
Cartesian3.normalize(north, north);
Cartesian3.multiplyByScalar(normal, radius, normal);
Cartesian3.multiplyByScalar(north, radius, north);
Cartesian3.multiplyByScalar(east, radius, east);
var south = Cartesian3.negate(north, projectTo2DSouthScratch);
var west = Cartesian3.negate(east, projectTo2DWestScratch);
var positions = projectTo2DPositionsScratch;
// top NE corner
var corner = positions[0];
Cartesian3.add(normal, north, corner);
Cartesian3.add(corner, east, corner);
// top NW corner
corner = positions[1];
Cartesian3.add(normal, north, corner);
Cartesian3.add(corner, west, corner);
// top SW corner
corner = positions[2];
Cartesian3.add(normal, south, corner);
Cartesian3.add(corner, west, corner);
// top SE corner
corner = positions[3];
Cartesian3.add(normal, south, corner);
Cartesian3.add(corner, east, corner);
Cartesian3.negate(normal, normal);
// bottom NE corner
corner = positions[4];
Cartesian3.add(normal, north, corner);
Cartesian3.add(corner, east, corner);
// bottom NW corner
corner = positions[5];
Cartesian3.add(normal, north, corner);
Cartesian3.add(corner, west, corner);
// bottom SW corner
corner = positions[6];
Cartesian3.add(normal, south, corner);
Cartesian3.add(corner, west, corner);
// bottom SE corner
corner = positions[7];
Cartesian3.add(normal, south, corner);
Cartesian3.add(corner, east, corner);
var length = positions.length;
for (var i = 0; i < length; ++i) {
var position = positions[i];
Cartesian3.add(center, position, position);
var cartographic = ellipsoid.cartesianToCartographic(position, projectTo2DCartographicScratch);
projection.project(cartographic, position);
}
result = BoundingSphere.fromPoints(positions, result);
// swizzle center components
center = result.center;
var x = center.x;
var y = center.y;
var z = center.z;
center.x = z;
center.y = x;
center.z = y;
return result;
};
/**
* Determines whether or not a sphere is hidden from view by the occluder.
*
* @param {BoundingSphere} sphere The bounding sphere surrounding the occludee object.
* @param {Occluder} occluder The occluder.
* @returns {Boolean} <code>true</code> if the sphere is not visible; otherwise <code>false</code>.
*/
BoundingSphere.isOccluded = function(sphere, occluder) {
Check.typeOf.object('sphere', sphere);
Check.typeOf.object('occluder', occluder);
return !occluder.isBoundingSphereVisible(sphere);
};
/**
* Compares the provided BoundingSphere componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {BoundingSphere} [left] The first BoundingSphere.
* @param {BoundingSphere} [right] The second BoundingSphere.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
BoundingSphere.equals = function(left, right) {
return (left === right) ||
((defined(left)) &&
(defined(right)) &&
Cartesian3.equals(left.center, right.center) &&
left.radius === right.radius);
};
/**
* Determines which side of a plane the sphere is located.
*
* @param {Plane} plane The plane to test against.
* @returns {Intersect} {@link Intersect.INSIDE} if the entire sphere is on the side of the plane
* the normal is pointing, {@link Intersect.OUTSIDE} if the entire sphere is
* on the opposite side, and {@link Intersect.INTERSECTING} if the sphere
* intersects the plane.
*/
BoundingSphere.prototype.intersectPlane = function(plane) {
return BoundingSphere.intersectPlane(this, plane);
};
/**
* Computes the estimated distance squared from the closest point on a bounding sphere to a point.
*
* @param {Cartesian3} cartesian The point
* @returns {Number} The estimated distance squared from the bounding sphere to the point.
*
* @example
* // Sort bounding spheres from back to front
* spheres.sort(function(a, b) {
* return b.distanceSquaredTo(camera.positionWC) - a.distanceSquaredTo(camera.positionWC);
* });
*/
BoundingSphere.prototype.distanceSquaredTo = function(cartesian) {
return BoundingSphere.distanceSquaredTo(this, cartesian);
};
/**
* The distances calculated by the vector from the center of the bounding sphere to position projected onto direction
* plus/minus the radius of the bounding sphere.
* <br>
* If you imagine the infinite number of planes with normal direction, this computes the smallest distance to the
* closest and farthest planes from position that intersect the bounding sphere.
*
* @param {Cartesian3} position The position to calculate the distance from.
* @param {Cartesian3} direction The direction from position.
* @param {Interval} [result] A Interval to store the nearest and farthest distances.
* @returns {Interval} The nearest and farthest distances on the bounding sphere from position in direction.
*/
BoundingSphere.prototype.computePlaneDistances = function(position, direction, result) {
return BoundingSphere.computePlaneDistances(this, position, direction, result);
};
/**
* Determines whether or not a sphere is hidden from view by the occluder.
*
* @param {Occluder} occluder The occluder.
* @returns {Boolean} <code>true</code> if the sphere is not visible; otherwise <code>false</code>.
*/
BoundingSphere.prototype.isOccluded = function(occluder) {
return BoundingSphere.isOccluded(this, occluder);
};
/**
* Compares this BoundingSphere against the provided BoundingSphere componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {BoundingSphere} [right] The right hand side BoundingSphere.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
BoundingSphere.prototype.equals = function(right) {
return BoundingSphere.equals(this, right);
};
/**
* Duplicates this BoundingSphere instance.
*
* @param {BoundingSphere} [result] The object onto which to store the result.
* @returns {BoundingSphere} The modified result parameter or a new BoundingSphere instance if none was provided.
*/
BoundingSphere.prototype.clone = function(result) {
return BoundingSphere.clone(this, result);
};
return BoundingSphere;
});
/*global define*/
define('Core/Fullscreen',[
'./defined',
'./defineProperties'
], function(
defined,
defineProperties) {
'use strict';
var _supportsFullscreen;
var _names = {
requestFullscreen : undefined,
exitFullscreen : undefined,
fullscreenEnabled : undefined,
fullscreenElement : undefined,
fullscreenchange : undefined,
fullscreenerror : undefined
};
/**
* Browser-independent functions for working with the standard fullscreen API.
*
* @exports Fullscreen
*
* @see {@link http://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html|W3C Fullscreen Living Specification}
*/
var Fullscreen = {};
defineProperties(Fullscreen, {
/**
* The element that is currently fullscreen, if any. To simply check if the
* browser is in fullscreen mode or not, use {@link Fullscreen#fullscreen}.
* @memberof Fullscreen
* @type {Object}
* @readonly
*/
element : {
get : function() {
if (!Fullscreen.supportsFullscreen()) {
return undefined;
}
return document[_names.fullscreenElement];
}
},
/**
* The name of the event on the document that is fired when fullscreen is
* entered or exited. This event name is intended for use with addEventListener.
* In your event handler, to determine if the browser is in fullscreen mode or not,
* use {@link Fullscreen#fullscreen}.
* @memberof Fullscreen
* @type {String}
* @readonly
*/
changeEventName : {
get : function() {
if (!Fullscreen.supportsFullscreen()) {
return undefined;
}
return _names.fullscreenchange;
}
},
/**
* The name of the event that is fired when a fullscreen error
* occurs. This event name is intended for use with addEventListener.
* @memberof Fullscreen
* @type {String}
* @readonly
*/
errorEventName : {
get : function() {
if (!Fullscreen.supportsFullscreen()) {
return undefined;
}
return _names.fullscreenerror;
}
},
/**
* Determine whether the browser will allow an element to be made fullscreen, or not.
* For example, by default, iframes cannot go fullscreen unless the containing page
* adds an "allowfullscreen" attribute (or prefixed equivalent).
* @memberof Fullscreen
* @type {Boolean}
* @readonly
*/
enabled : {
get : function() {
if (!Fullscreen.supportsFullscreen()) {
return undefined;
}
return document[_names.fullscreenEnabled];
}
},
/**
* Determines if the browser is currently in fullscreen mode.
* @memberof Fullscreen
* @type {Boolean}
* @readonly
*/
fullscreen : {
get : function() {
if (!Fullscreen.supportsFullscreen()) {
return undefined;
}
return Fullscreen.element !== null;
}
}
});
/**
* Detects whether the browser supports the standard fullscreen API.
*
* @returns {Boolean} <code>true</code> if the browser supports the standard fullscreen API,
* <code>false</code> otherwise.
*/
Fullscreen.supportsFullscreen = function() {
if (defined(_supportsFullscreen)) {
return _supportsFullscreen;
}
_supportsFullscreen = false;
var body = document.body;
if (typeof body.requestFullscreen === 'function') {
// go with the unprefixed, standard set of names
_names.requestFullscreen = 'requestFullscreen';
_names.exitFullscreen = 'exitFullscreen';
_names.fullscreenEnabled = 'fullscreenEnabled';
_names.fullscreenElement = 'fullscreenElement';
_names.fullscreenchange = 'fullscreenchange';
_names.fullscreenerror = 'fullscreenerror';
_supportsFullscreen = true;
return _supportsFullscreen;
}
//check for the correct combination of prefix plus the various names that browsers use
var prefixes = ['webkit', 'moz', 'o', 'ms', 'khtml'];
var name;
for (var i = 0, len = prefixes.length; i < len; ++i) {
var prefix = prefixes[i];
// casing of Fullscreen differs across browsers
name = prefix + 'RequestFullscreen';
if (typeof body[name] === 'function') {
_names.requestFullscreen = name;
_supportsFullscreen = true;
} else {
name = prefix + 'RequestFullScreen';
if (typeof body[name] === 'function') {
_names.requestFullscreen = name;
_supportsFullscreen = true;
}
}
// disagreement about whether it's "exit" as per spec, or "cancel"
name = prefix + 'ExitFullscreen';
if (typeof document[name] === 'function') {
_names.exitFullscreen = name;
} else {
name = prefix + 'CancelFullScreen';
if (typeof document[name] === 'function') {
_names.exitFullscreen = name;
}
}
// casing of Fullscreen differs across browsers
name = prefix + 'FullscreenEnabled';
if (document[name] !== undefined) {
_names.fullscreenEnabled = name;
} else {
name = prefix + 'FullScreenEnabled';
if (document[name] !== undefined) {
_names.fullscreenEnabled = name;
}
}
// casing of Fullscreen differs across browsers
name = prefix + 'FullscreenElement';
if (document[name] !== undefined) {
_names.fullscreenElement = name;
} else {
name = prefix + 'FullScreenElement';
if (document[name] !== undefined) {
_names.fullscreenElement = name;
}
}
// thankfully, event names are all lowercase per spec
name = prefix + 'fullscreenchange';
// event names do not have 'on' in the front, but the property on the document does
if (document['on' + name] !== undefined) {
//except on IE
if (prefix === 'ms') {
name = 'MSFullscreenChange';
}
_names.fullscreenchange = name;
}
name = prefix + 'fullscreenerror';
if (document['on' + name] !== undefined) {
//except on IE
if (prefix === 'ms') {
name = 'MSFullscreenError';
}
_names.fullscreenerror = name;
}
}
return _supportsFullscreen;
};
/**
* Asynchronously requests the browser to enter fullscreen mode on the given element.
* If fullscreen mode is not supported by the browser, does nothing.
*
* @param {Object} element The HTML element which will be placed into fullscreen mode.
* @param {HMDVRDevice} [vrDevice] The VR device.
*
* @example
* // Put the entire page into fullscreen.
* Cesium.Fullscreen.requestFullscreen(document.body)
*
* // Place only the Cesium canvas into fullscreen.
* Cesium.Fullscreen.requestFullscreen(scene.canvas)
*/
Fullscreen.requestFullscreen = function(element, vrDevice) {
if (!Fullscreen.supportsFullscreen()) {
return;
}
element[_names.requestFullscreen]({ vrDisplay: vrDevice });
};
/**
* Asynchronously exits fullscreen mode. If the browser is not currently
* in fullscreen, or if fullscreen mode is not supported by the browser, does nothing.
*/
Fullscreen.exitFullscreen = function() {
if (!Fullscreen.supportsFullscreen()) {
return;
}
document[_names.exitFullscreen]();
};
return Fullscreen;
});
/*global define*/
define('Core/FeatureDetection',[
'./defaultValue',
'./defined',
'./Fullscreen'
], function(
defaultValue,
defined,
Fullscreen) {
'use strict';
var theNavigator;
if (typeof navigator !== 'undefined') {
theNavigator = navigator;
} else {
theNavigator = {};
}
function extractVersion(versionString) {
var parts = versionString.split('.');
for (var i = 0, len = parts.length; i < len; ++i) {
parts[i] = parseInt(parts[i], 10);
}
return parts;
}
var isChromeResult;
var chromeVersionResult;
function isChrome() {
if (!defined(isChromeResult)) {
isChromeResult = false;
// Edge contains Chrome in the user agent too
if (!isEdge()) {
var fields = (/ Chrome\/([\.0-9]+)/).exec(theNavigator.userAgent);
if (fields !== null) {
isChromeResult = true;
chromeVersionResult = extractVersion(fields[1]);
}
}
}
return isChromeResult;
}
function chromeVersion() {
return isChrome() && chromeVersionResult;
}
var isSafariResult;
var safariVersionResult;
function isSafari() {
if (!defined(isSafariResult)) {
isSafariResult = false;
// Chrome and Edge contain Safari in the user agent too
if (!isChrome() && !isEdge() && (/ Safari\/[\.0-9]+/).test(theNavigator.userAgent)) {
var fields = (/ Version\/([\.0-9]+)/).exec(theNavigator.userAgent);
if (fields !== null) {
isSafariResult = true;
safariVersionResult = extractVersion(fields[1]);
}
}
}
return isSafariResult;
}
function safariVersion() {
return isSafari() && safariVersionResult;
}
var isWebkitResult;
var webkitVersionResult;
function isWebkit() {
if (!defined(isWebkitResult)) {
isWebkitResult = false;
var fields = (/ AppleWebKit\/([\.0-9]+)(\+?)/).exec(theNavigator.userAgent);
if (fields !== null) {
isWebkitResult = true;
webkitVersionResult = extractVersion(fields[1]);
webkitVersionResult.isNightly = !!fields[2];
}
}
return isWebkitResult;
}
function webkitVersion() {
return isWebkit() && webkitVersionResult;
}
var isInternetExplorerResult;
var internetExplorerVersionResult;
function isInternetExplorer() {
if (!defined(isInternetExplorerResult)) {
isInternetExplorerResult = false;
var fields;
if (theNavigator.appName === 'Microsoft Internet Explorer') {
fields = /MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(theNavigator.userAgent);
if (fields !== null) {
isInternetExplorerResult = true;
internetExplorerVersionResult = extractVersion(fields[1]);
}
} else if (theNavigator.appName === 'Netscape') {
fields = /Trident\/.*rv:([0-9]{1,}[\.0-9]{0,})/.exec(theNavigator.userAgent);
if (fields !== null) {
isInternetExplorerResult = true;
internetExplorerVersionResult = extractVersion(fields[1]);
}
}
}
return isInternetExplorerResult;
}
function internetExplorerVersion() {
return isInternetExplorer() && internetExplorerVersionResult;
}
var isEdgeResult;
var edgeVersionResult;
function isEdge() {
if (!defined(isEdgeResult)) {
isEdgeResult = false;
var fields = (/ Edge\/([\.0-9]+)/).exec(theNavigator.userAgent);
if (fields !== null) {
isEdgeResult = true;
edgeVersionResult = extractVersion(fields[1]);
}
}
return isEdgeResult;
}
function edgeVersion() {
return isEdge() && edgeVersionResult;
}
var isFirefoxResult;
var firefoxVersionResult;
function isFirefox() {
if (!defined(isFirefoxResult)) {
isFirefoxResult = false;
var fields = /Firefox\/([\.0-9]+)/.exec(theNavigator.userAgent);
if (fields !== null) {
isFirefoxResult = true;
firefoxVersionResult = extractVersion(fields[1]);
}
}
return isFirefoxResult;
}
var isWindowsResult;
function isWindows() {
if (!defined(isWindowsResult)) {
isWindowsResult = /Windows/i.test(theNavigator.appVersion);
}
return isWindowsResult;
}
function firefoxVersion() {
return isFirefox() && firefoxVersionResult;
}
var hasPointerEvents;
function supportsPointerEvents() {
if (!defined(hasPointerEvents)) {
//While navigator.pointerEnabled is deprecated in the W3C specification
//we still need to use it if it exists in order to support browsers
//that rely on it, such as the Windows WebBrowser control which defines
//PointerEvent but sets navigator.pointerEnabled to false.
hasPointerEvents = typeof PointerEvent !== 'undefined' && (!defined(theNavigator.pointerEnabled) || theNavigator.pointerEnabled);
}
return hasPointerEvents;
}
var imageRenderingValueResult;
var supportsImageRenderingPixelatedResult;
function supportsImageRenderingPixelated() {
if (!defined(supportsImageRenderingPixelatedResult)) {
var canvas = document.createElement('canvas');
canvas.setAttribute('style',
'image-rendering: -moz-crisp-edges;' +
'image-rendering: pixelated;');
//canvas.style.imageRendering will be undefined, null or an empty string on unsupported browsers.
var tmp = canvas.style.imageRendering;
supportsImageRenderingPixelatedResult = defined(tmp) && tmp !== '';
if (supportsImageRenderingPixelatedResult) {
imageRenderingValueResult = tmp;
}
}
return supportsImageRenderingPixelatedResult;
}
function imageRenderingValue() {
return supportsImageRenderingPixelated() ? imageRenderingValueResult : undefined;
}
/**
* A set of functions to detect whether the current browser supports
* various features.
*
* @exports FeatureDetection
*/
var FeatureDetection = {
isChrome : isChrome,
chromeVersion : chromeVersion,
isSafari : isSafari,
safariVersion : safariVersion,
isWebkit : isWebkit,
webkitVersion : webkitVersion,
isInternetExplorer : isInternetExplorer,
internetExplorerVersion : internetExplorerVersion,
isEdge : isEdge,
edgeVersion : edgeVersion,
isFirefox : isFirefox,
firefoxVersion : firefoxVersion,
isWindows : isWindows,
hardwareConcurrency : defaultValue(theNavigator.hardwareConcurrency, 3),
supportsPointerEvents : supportsPointerEvents,
supportsImageRenderingPixelated: supportsImageRenderingPixelated,
imageRenderingValue: imageRenderingValue
};
/**
* Detects whether the current browser supports the full screen standard.
*
* @returns {Boolean} true if the browser supports the full screen standard, false if not.
*
* @see Fullscreen
* @see {@link http://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html|W3C Fullscreen Living Specification}
*/
FeatureDetection.supportsFullscreen = function() {
return Fullscreen.supportsFullscreen();
};
/**
* Detects whether the current browser supports typed arrays.
*
* @returns {Boolean} true if the browser supports typed arrays, false if not.
*
* @see {@link http://www.khronos.org/registry/typedarray/specs/latest/|Typed Array Specification}
*/
FeatureDetection.supportsTypedArrays = function() {
return typeof ArrayBuffer !== 'undefined';
};
/**
* Detects whether the current browser supports Web Workers.
*
* @returns {Boolean} true if the browsers supports Web Workers, false if not.
*
* @see {@link http://www.w3.org/TR/workers/}
*/
FeatureDetection.supportsWebWorkers = function() {
return typeof Worker !== 'undefined';
};
return FeatureDetection;
});
/*global define*/
define('Core/Color',[
'./defaultValue',
'./defined',
'./DeveloperError',
'./FeatureDetection',
'./freezeObject',
'./Math'
], function(
defaultValue,
defined,
DeveloperError,
FeatureDetection,
freezeObject,
CesiumMath) {
'use strict';
function hue2rgb(m1, m2, h) {
if (h < 0) {
h += 1;
}
if (h > 1) {
h -= 1;
}
if (h * 6 < 1) {
return m1 + (m2 - m1) * 6 * h;
}
if (h * 2 < 1) {
return m2;
}
if (h * 3 < 2) {
return m1 + (m2 - m1) * (2 / 3 - h) * 6;
}
return m1;
}
/**
* A color, specified using red, green, blue, and alpha values,
* which range from <code>0</code> (no intensity) to <code>1.0</code> (full intensity).
* @param {Number} [red=1.0] The red component.
* @param {Number} [green=1.0] The green component.
* @param {Number} [blue=1.0] The blue component.
* @param {Number} [alpha=1.0] The alpha component.
*
* @constructor
* @alias Color
*
* @see Packable
*/
function Color(red, green, blue, alpha) {
/**
* The red component.
* @type {Number}
* @default 1.0
*/
this.red = defaultValue(red, 1.0);
/**
* The green component.
* @type {Number}
* @default 1.0
*/
this.green = defaultValue(green, 1.0);
/**
* The blue component.
* @type {Number}
* @default 1.0
*/
this.blue = defaultValue(blue, 1.0);
/**
* The alpha component.
* @type {Number}
* @default 1.0
*/
this.alpha = defaultValue(alpha, 1.0);
}
/**
* Creates a Color instance from a {@link Cartesian4}. <code>x</code>, <code>y</code>, <code>z</code>,
* and <code>w</code> map to <code>red</code>, <code>green</code>, <code>blue</code>, and <code>alpha</code>, respectively.
*
* @param {Cartesian4} cartesian The source cartesian.
* @param {Color} [result] The object onto which to store the result.
* @returns {Color} The modified result parameter or a new Color instance if one was not provided.
*/
Color.fromCartesian4 = function(cartesian, result) {
if (!defined(cartesian)) {
throw new DeveloperError('cartesian is required');
}
if (!defined(result)) {
return new Color(cartesian.x, cartesian.y, cartesian.z, cartesian.w);
}
result.red = cartesian.x;
result.green = cartesian.y;
result.blue = cartesian.z;
result.alpha = cartesian.w;
return result;
};
/**
* Creates a new Color specified using red, green, blue, and alpha values
* that are in the range of 0 to 255, converting them internally to a range of 0.0 to 1.0.
*
* @param {Number} [red=255] The red component.
* @param {Number} [green=255] The green component.
* @param {Number} [blue=255] The blue component.
* @param {Number} [alpha=255] The alpha component.
* @param {Color} [result] The object onto which to store the result.
* @returns {Color} The modified result parameter or a new Color instance if one was not provided.
*/
Color.fromBytes = function(red, green, blue, alpha, result) {
red = Color.byteToFloat(defaultValue(red, 255.0));
green = Color.byteToFloat(defaultValue(green, 255.0));
blue = Color.byteToFloat(defaultValue(blue, 255.0));
alpha = Color.byteToFloat(defaultValue(alpha, 255.0));
if (!defined(result)) {
return new Color(red, green, blue, alpha);
}
result.red = red;
result.green = green;
result.blue = blue;
result.alpha = alpha;
return result;
};
/**
* Creates a new Color that has the same red, green, and blue components
* of the specified color, but with the specified alpha value.
*
* @param {Color} color The base color
* @param {Number} alpha The new alpha component.
* @param {Color} [result] The object onto which to store the result.
* @returns {Color} The modified result parameter or a new Color instance if one was not provided.
*
* @example var translucentRed = Cesium.Color.fromAlpha(Cesium.Color.RED, 0.9);
*/
Color.fromAlpha = function(color, alpha, result) {
if (!defined(color)) {
throw new DeveloperError('color is required');
}
if (!defined(alpha)) {
throw new DeveloperError('alpha is required');
}
if (!defined(result)) {
return new Color(color.red, color.green, color.blue, alpha);
}
result.red = color.red;
result.green = color.green;
result.blue = color.blue;
result.alpha = alpha;
return result;
};
var scratchArrayBuffer;
var scratchUint32Array;
var scratchUint8Array;
if (FeatureDetection.supportsTypedArrays()) {
scratchArrayBuffer = new ArrayBuffer(4);
scratchUint32Array = new Uint32Array(scratchArrayBuffer);
scratchUint8Array = new Uint8Array(scratchArrayBuffer);
}
/**
* Creates a new Color from a single numeric unsigned 32-bit RGBA value, using the endianness
* of the system.
*
* @param {Number} rgba A single numeric unsigned 32-bit RGBA value.
* @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
* @returns {Color} The color object.
*
* @example
* var color = Cesium.Color.fromRgba(0x67ADDFFF);
*
* @see Color#toRgba
*/
Color.fromRgba = function(rgba, result) {
// scratchUint32Array and scratchUint8Array share an underlying array buffer
scratchUint32Array[0] = rgba;
return Color.fromBytes(scratchUint8Array[0], scratchUint8Array[1], scratchUint8Array[2], scratchUint8Array[3], result);
};
/**
* Creates a Color instance from hue, saturation, and lightness.
*
* @param {Number} [hue=0] The hue angle 0...1
* @param {Number} [saturation=0] The saturation value 0...1
* @param {Number} [lightness=0] The lightness value 0...1
* @param {Number} [alpha=1.0] The alpha component 0...1
* @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
* @returns {Color} The color object.
*
* @see {@link http://www.w3.org/TR/css3-color/#hsl-color|CSS color values}
*/
Color.fromHsl = function(hue, saturation, lightness, alpha, result) {
hue = defaultValue(hue, 0.0) % 1.0;
saturation = defaultValue(saturation, 0.0);
lightness = defaultValue(lightness, 0.0);
alpha = defaultValue(alpha, 1.0);
var red = lightness;
var green = lightness;
var blue = lightness;
if (saturation !== 0) {
var m2;
if (lightness < 0.5) {
m2 = lightness * (1 + saturation);
} else {
m2 = lightness + saturation - lightness * saturation;
}
var m1 = 2.0 * lightness - m2;
red = hue2rgb(m1, m2, hue + 1 / 3);
green = hue2rgb(m1, m2, hue);
blue = hue2rgb(m1, m2, hue - 1 / 3);
}
if (!defined(result)) {
return new Color(red, green, blue, alpha);
}
result.red = red;
result.green = green;
result.blue = blue;
result.alpha = alpha;
return result;
};
/**
* Creates a random color using the provided options. For reproducible random colors, you should
* call {@link CesiumMath#setRandomNumberSeed} once at the beginning of your application.
*
* @param {Object} [options] Object with the following properties:
* @param {Number} [options.red] If specified, the red component to use instead of a randomized value.
* @param {Number} [options.minimumRed=0.0] The maximum red value to generate if none was specified.
* @param {Number} [options.maximumRed=1.0] The minimum red value to generate if none was specified.
* @param {Number} [options.green] If specified, the green component to use instead of a randomized value.
* @param {Number} [options.minimumGreen=0.0] The maximum green value to generate if none was specified.
* @param {Number} [options.maximumGreen=1.0] The minimum green value to generate if none was specified.
* @param {Number} [options.blue] If specified, the blue component to use instead of a randomized value.
* @param {Number} [options.minimumBlue=0.0] The maximum blue value to generate if none was specified.
* @param {Number} [options.maximumBlue=1.0] The minimum blue value to generate if none was specified.
* @param {Number} [options.alpha] If specified, the alpha component to use instead of a randomized value.
* @param {Number} [options.minimumAlpha=0.0] The maximum alpha value to generate if none was specified.
* @param {Number} [options.maximumAlpha=1.0] The minimum alpha value to generate if none was specified.
* @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
* @returns {Color} The modified result parameter or a new instance if result was undefined.
*
* @exception {DeveloperError} minimumRed must be less than or equal to maximumRed.
* @exception {DeveloperError} minimumGreen must be less than or equal to maximumGreen.
* @exception {DeveloperError} minimumBlue must be less than or equal to maximumBlue.
* @exception {DeveloperError} minimumAlpha must be less than or equal to maximumAlpha.
*
* @example
* //Create a completely random color
* var color = Cesium.Color.fromRandom();
*
* //Create a random shade of yellow.
* var color = Cesium.Color.fromRandom({
* red : 1.0,
* green : 1.0,
* alpha : 1.0
* });
*
* //Create a random bright color.
* var color = Cesium.Color.fromRandom({
* minimumRed : 0.75,
* minimumGreen : 0.75,
* minimumBlue : 0.75,
* alpha : 1.0
* });
*/
Color.fromRandom = function(options, result) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var red = options.red;
if (!defined(red)) {
var minimumRed = defaultValue(options.minimumRed, 0);
var maximumRed = defaultValue(options.maximumRed, 1.0);
if (minimumRed > maximumRed) {
throw new DeveloperError("minimumRed must be less than or equal to maximumRed");
}
red = minimumRed + (CesiumMath.nextRandomNumber() * (maximumRed - minimumRed));
}
var green = options.green;
if (!defined(green)) {
var minimumGreen = defaultValue(options.minimumGreen, 0);
var maximumGreen = defaultValue(options.maximumGreen, 1.0);
if (minimumGreen > maximumGreen) {
throw new DeveloperError("minimumGreen must be less than or equal to maximumGreen");
}
green = minimumGreen + (CesiumMath.nextRandomNumber() * (maximumGreen - minimumGreen));
}
var blue = options.blue;
if (!defined(blue)) {
var minimumBlue = defaultValue(options.minimumBlue, 0);
var maximumBlue = defaultValue(options.maximumBlue, 1.0);
if (minimumBlue > maximumBlue) {
throw new DeveloperError("minimumBlue must be less than or equal to maximumBlue");
}
blue = minimumBlue + (CesiumMath.nextRandomNumber() * (maximumBlue - minimumBlue));
}
var alpha = options.alpha;
if (!defined(alpha)) {
var minimumAlpha = defaultValue(options.minimumAlpha, 0);
var maximumAlpha = defaultValue(options.maximumAlpha, 1.0);
if (minimumAlpha > maximumAlpha) {
throw new DeveloperError("minimumAlpha must be less than or equal to maximumAlpha");
}
alpha = minimumAlpha + (CesiumMath.nextRandomNumber() * (maximumAlpha - minimumAlpha));
}
if (!defined(result)) {
return new Color(red, green, blue, alpha);
}
result.red = red;
result.green = green;
result.blue = blue;
result.alpha = alpha;
return result;
};
//#rgb
var rgbMatcher = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i;
//#rrggbb
var rrggbbMatcher = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
//rgb(), rgba(), or rgb%()
var rgbParenthesesMatcher = /^rgba?\(\s*([0-9.]+%?)\s*,\s*([0-9.]+%?)\s*,\s*([0-9.]+%?)(?:\s*,\s*([0-9.]+))?\s*\)$/i;
//hsl(), hsla(), or hsl%()
var hslParenthesesMatcher = /^hsla?\(\s*([0-9.]+)\s*,\s*([0-9.]+%)\s*,\s*([0-9.]+%)(?:\s*,\s*([0-9.]+))?\s*\)$/i;
/**
* Creates a Color instance from a CSS color value.
*
* @param {String} color The CSS color value in #rgb, #rrggbb, rgb(), rgba(), hsl(), or hsla() format.
* @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
* @returns {Color} The color object, or undefined if the string was not a valid CSS color.
*
*
* @example
* var cesiumBlue = Cesium.Color.fromCssColorString('#67ADDF');
* var green = Cesium.Color.fromCssColorString('green');
*
* @see {@link http://www.w3.org/TR/css3-color|CSS color values}
*/
Color.fromCssColorString = function(color, result) {
if (!defined(color)) {
throw new DeveloperError('color is required');
}
if (!defined(result)) {
result = new Color();
}
var namedColor = Color[color.toUpperCase()];
if (defined(namedColor)) {
Color.clone(namedColor, result);
return result;
}
var matches = rgbMatcher.exec(color);
if (matches !== null) {
result.red = parseInt(matches[1], 16) / 15;
result.green = parseInt(matches[2], 16) / 15.0;
result.blue = parseInt(matches[3], 16) / 15.0;
result.alpha = 1.0;
return result;
}
matches = rrggbbMatcher.exec(color);
if (matches !== null) {
result.red = parseInt(matches[1], 16) / 255.0;
result.green = parseInt(matches[2], 16) / 255.0;
result.blue = parseInt(matches[3], 16) / 255.0;
result.alpha = 1.0;
return result;
}
matches = rgbParenthesesMatcher.exec(color);
if (matches !== null) {
result.red = parseFloat(matches[1]) / ('%' === matches[1].substr(-1) ? 100.0 : 255.0);
result.green = parseFloat(matches[2]) / ('%' === matches[2].substr(-1) ? 100.0 : 255.0);
result.blue = parseFloat(matches[3]) / ('%' === matches[3].substr(-1) ? 100.0 : 255.0);
result.alpha = parseFloat(defaultValue(matches[4], '1.0'));
return result;
}
matches = hslParenthesesMatcher.exec(color);
if (matches !== null) {
return Color.fromHsl(parseFloat(matches[1]) / 360.0,
parseFloat(matches[2]) / 100.0,
parseFloat(matches[3]) / 100.0,
parseFloat(defaultValue(matches[4], '1.0')), result);
}
result = undefined;
return result;
};
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Color.packedLength = 4;
/**
* Stores the provided instance into the provided array.
*
* @param {Color} 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
*/
Color.pack = function(value, array, startingIndex) {
if (!defined(value)) {
throw new DeveloperError('value is required');
}
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value.red;
array[startingIndex++] = value.green;
array[startingIndex++] = value.blue;
array[startingIndex] = value.alpha;
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 {Color} [result] The object into which to store the result.
* @returns {Color} The modified result parameter or a new Color instance if one was not provided.
*/
Color.unpack = function(array, startingIndex, result) {
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Color();
}
result.red = array[startingIndex++];
result.green = array[startingIndex++];
result.blue = array[startingIndex++];
result.alpha = array[startingIndex];
return result;
};
/**
* Converts a 'byte' color component in the range of 0 to 255 into
* a 'float' color component in the range of 0 to 1.0.
*
* @param {Number} number The number to be converted.
* @returns {Number} The converted number.
*/
Color.byteToFloat = function(number) {
return number / 255.0;
};
/**
* Converts a 'float' color component in the range of 0 to 1.0 into
* a 'byte' color component in the range of 0 to 255.
*
* @param {Number} number The number to be converted.
* @returns {Number} The converted number.
*/
Color.floatToByte = function(number) {
return number === 1.0 ? 255.0 : (number * 256.0) | 0;
};
/**
* Duplicates a Color.
*
* @param {Color} color The Color to duplicate.
* @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
* @returns {Color} The modified result parameter or a new instance if result was undefined. (Returns undefined if color is undefined)
*/
Color.clone = function(color, result) {
if (!defined(color)) {
return undefined;
}
if (!defined(result)) {
return new Color(color.red, color.green, color.blue, color.alpha);
}
result.red = color.red;
result.green = color.green;
result.blue = color.blue;
result.alpha = color.alpha;
return result;
};
/**
* Returns true if the first Color equals the second color.
*
* @param {Color} left The first Color to compare for equality.
* @param {Color} right The second Color to compare for equality.
* @returns {Boolean} <code>true</code> if the Colors are equal; otherwise, <code>false</code>.
*/
Color.equals = function(left, right) {
return (left === right) || //
(defined(left) && //
defined(right) && //
left.red === right.red && //
left.green === right.green && //
left.blue === right.blue && //
left.alpha === right.alpha);
};
/**
* @private
*/
Color.equalsArray = function(color, array, offset) {
return color.red === array[offset] &&
color.green === array[offset + 1] &&
color.blue === array[offset + 2] &&
color.alpha === array[offset + 3];
};
/**
* Returns a duplicate of a Color instance.
*
* @param {Color} [result] The object to store the result in, if undefined a new instance will be created.
* @returns {Color} The modified result parameter or a new instance if result was undefined.
*/
Color.prototype.clone = function(result) {
return Color.clone(this, result);
};
/**
* Returns true if this Color equals other.
*
* @param {Color} other The Color to compare for equality.
* @returns {Boolean} <code>true</code> if the Colors are equal; otherwise, <code>false</code>.
*/
Color.prototype.equals = function(other) {
return Color.equals(this, other);
};
/**
* Returns <code>true</code> if this Color equals other componentwise within the specified epsilon.
*
* @param {Color} other The Color to compare for equality.
* @param {Number} [epsilon=0.0] The epsilon to use for equality testing.
* @returns {Boolean} <code>true</code> if the Colors are equal within the specified epsilon; otherwise, <code>false</code>.
*/
Color.prototype.equalsEpsilon = function(other, epsilon) {
return (this === other) || //
((defined(other)) && //
(Math.abs(this.red - other.red) <= epsilon) && //
(Math.abs(this.green - other.green) <= epsilon) && //
(Math.abs(this.blue - other.blue) <= epsilon) && //
(Math.abs(this.alpha - other.alpha) <= epsilon));
};
/**
* Creates a string representing this Color in the format '(red, green, blue, alpha)'.
*
* @returns {String} A string representing this Color in the format '(red, green, blue, alpha)'.
*/
Color.prototype.toString = function() {
return '(' + this.red + ', ' + this.green + ', ' + this.blue + ', ' + this.alpha + ')';
};
/**
* Creates a string containing the CSS color value for this color.
*
* @returns {String} The CSS equivalent of this color.
*
* @see {@link http://www.w3.org/TR/css3-color/#rgba-color|CSS RGB or RGBA color values}
*/
Color.prototype.toCssColorString = function() {
var red = Color.floatToByte(this.red);
var green = Color.floatToByte(this.green);
var blue = Color.floatToByte(this.blue);
if (this.alpha === 1) {
return 'rgb(' + red + ',' + green + ',' + blue + ')';
}
return 'rgba(' + red + ',' + green + ',' + blue + ',' + this.alpha + ')';
};
/**
* Converts this color to an array of red, green, blue, and alpha values
* that are in the range of 0 to 255.
*
* @param {Number[]} [result] The array to store the result in, if undefined a new instance will be created.
* @returns {Number[]} The modified result parameter or a new instance if result was undefined.
*/
Color.prototype.toBytes = function(result) {
var red = Color.floatToByte(this.red);
var green = Color.floatToByte(this.green);
var blue = Color.floatToByte(this.blue);
var alpha = Color.floatToByte(this.alpha);
if (!defined(result)) {
return [red, green, blue, alpha];
}
result[0] = red;
result[1] = green;
result[2] = blue;
result[3] = alpha;
return result;
};
/**
* Converts this color to a single numeric unsigned 32-bit RGBA value, using the endianness
* of the system.
*
* @returns {Number} A single numeric unsigned 32-bit RGBA value.
*
*
* @example
* var rgba = Cesium.Color.BLUE.toRgba();
*
* @see Color.fromRgba
*/
Color.prototype.toRgba = function() {
// scratchUint32Array and scratchUint8Array share an underlying array buffer
scratchUint8Array[0] = Color.floatToByte(this.red);
scratchUint8Array[1] = Color.floatToByte(this.green);
scratchUint8Array[2] = Color.floatToByte(this.blue);
scratchUint8Array[3] = Color.floatToByte(this.alpha);
return scratchUint32Array[0];
};
/**
* Brightens this color by the provided magnitude.
*
* @param {Number} magnitude A positive number indicating the amount to brighten.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*
* @example
* var brightBlue = Cesium.Color.BLUE.brighten(0.5, new Cesium.Color());
*/
Color.prototype.brighten = function(magnitude, result) {
if (!defined(magnitude)) {
throw new DeveloperError('magnitude is required.');
}
if (magnitude < 0.0) {
throw new DeveloperError('magnitude must be positive.');
}
if (!defined(result)) {
throw new DeveloperError('result is required.');
}
magnitude = (1.0 - magnitude);
result.red = 1.0 - ((1.0 - this.red) * magnitude);
result.green = 1.0 - ((1.0 - this.green) * magnitude);
result.blue = 1.0 - ((1.0 - this.blue) * magnitude);
result.alpha = this.alpha;
return result;
};
/**
* Darkens this color by the provided magnitude.
*
* @param {Number} magnitude A positive number indicating the amount to darken.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*
* @example
* var darkBlue = Cesium.Color.BLUE.darken(0.5, new Cesium.Color());
*/
Color.prototype.darken = function(magnitude, result) {
if (!defined(magnitude)) {
throw new DeveloperError('magnitude is required.');
}
if (magnitude < 0.0) {
throw new DeveloperError('magnitude must be positive.');
}
if (!defined(result)) {
throw new DeveloperError('result is required.');
}
magnitude = (1.0 - magnitude);
result.red = this.red * magnitude;
result.green = this.green * magnitude;
result.blue = this.blue * magnitude;
result.alpha = this.alpha;
return result;
};
/**
* Creates a new Color that has the same red, green, and blue components
* as this Color, but with the specified alpha value.
*
* @param {Number} alpha The new alpha component.
* @param {Color} [result] The object onto which to store the result.
* @returns {Color} The modified result parameter or a new Color instance if one was not provided.
*
* @example var translucentRed = Cesium.Color.RED.withAlpha(0.9);
*/
Color.prototype.withAlpha = function(alpha, result) {
return Color.fromAlpha(this, alpha, result);
};
/**
* Computes the componentwise sum of two Colors.
*
* @param {Color} left The first Color.
* @param {Color} right The second Color.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*/
Color.add = function(left, right, result) {
if (!defined(left)) {
throw new DeveloperError('left is required');
}
if (!defined(right)) {
throw new DeveloperError('right is required');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.red = left.red + right.red;
result.green = left.green + right.green;
result.blue = left.blue + right.blue;
result.alpha = left.alpha + right.alpha;
return result;
};
/**
* Computes the componentwise difference of two Colors.
*
* @param {Color} left The first Color.
* @param {Color} right The second Color.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*/
Color.subtract = function(left, right, result) {
if (!defined(left)) {
throw new DeveloperError('left is required');
}
if (!defined(right)) {
throw new DeveloperError('right is required');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.red = left.red - right.red;
result.green = left.green - right.green;
result.blue = left.blue - right.blue;
result.alpha = left.alpha - right.alpha;
return result;
};
/**
* Computes the componentwise product of two Colors.
*
* @param {Color} left The first Color.
* @param {Color} right The second Color.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*/
Color.multiply = function(left, right, result) {
if (!defined(left)) {
throw new DeveloperError('left is required');
}
if (!defined(right)) {
throw new DeveloperError('right is required');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.red = left.red * right.red;
result.green = left.green * right.green;
result.blue = left.blue * right.blue;
result.alpha = left.alpha * right.alpha;
return result;
};
/**
* Computes the componentwise quotient of two Colors.
*
* @param {Color} left The first Color.
* @param {Color} right The second Color.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*/
Color.divide = function(left, right, result) {
if (!defined(left)) {
throw new DeveloperError('left is required');
}
if (!defined(right)) {
throw new DeveloperError('right is required');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.red = left.red / right.red;
result.green = left.green / right.green;
result.blue = left.blue / right.blue;
result.alpha = left.alpha / right.alpha;
return result;
};
/**
* Computes the componentwise modulus of two Colors.
*
* @param {Color} left The first Color.
* @param {Color} right The second Color.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*/
Color.mod = function(left, right, result) {
if (!defined(left)) {
throw new DeveloperError('left is required');
}
if (!defined(right)) {
throw new DeveloperError('right is required');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.red = left.red % right.red;
result.green = left.green % right.green;
result.blue = left.blue % right.blue;
result.alpha = left.alpha % right.alpha;
return result;
};
/**
* Multiplies the provided Color componentwise by the provided scalar.
*
* @param {Color} color The Color to be scaled.
* @param {Number} scalar The scalar to multiply with.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*/
Color.multiplyByScalar = function(color, scalar, result) {
if (!defined(color)) {
throw new DeveloperError('cartesian is required');
}
if (typeof scalar !== 'number') {
throw new DeveloperError('scalar is required and must be a number.');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.red = color.red * scalar;
result.green = color.green * scalar;
result.blue = color.blue * scalar;
result.alpha = color.alpha * scalar;
return result;
};
/**
* Divides the provided Color componentwise by the provided scalar.
*
* @param {Color} color The Color to be divided.
* @param {Number} scalar The scalar to divide with.
* @param {Color} result The object onto which to store the result.
* @returns {Color} The modified result parameter.
*/
Color.divideByScalar = function(color, scalar, result) {
if (!defined(color)) {
throw new DeveloperError('cartesian is required');
}
if (typeof scalar !== 'number') {
throw new DeveloperError('scalar is required and must be a number.');
}
if (!defined(result)) {
throw new DeveloperError('result is required');
}
result.red = color.red / scalar;
result.green = color.green / scalar;
result.blue = color.blue / scalar;
result.alpha = color.alpha / scalar;
return result;
};
/**
* An immutable Color instance initialized to CSS color #F0F8FF
* <span class="colorSwath" style="background: #F0F8FF;"></span>
*
* @constant
* @type {Color}
*/
Color.ALICEBLUE = freezeObject(Color.fromCssColorString('#F0F8FF'));
/**
* An immutable Color instance initialized to CSS color #FAEBD7
* <span class="colorSwath" style="background: #FAEBD7;"></span>
*
* @constant
* @type {Color}
*/
Color.ANTIQUEWHITE = freezeObject(Color.fromCssColorString('#FAEBD7'));
/**
* An immutable Color instance initialized to CSS color #00FFFF
* <span class="colorSwath" style="background: #00FFFF;"></span>
*
* @constant
* @type {Color}
*/
Color.AQUA = freezeObject(Color.fromCssColorString('#00FFFF'));
/**
* An immutable Color instance initialized to CSS color #7FFFD4
* <span class="colorSwath" style="background: #7FFFD4;"></span>
*
* @constant
* @type {Color}
*/
Color.AQUAMARINE = freezeObject(Color.fromCssColorString('#7FFFD4'));
/**
* An immutable Color instance initialized to CSS color #F0FFFF
* <span class="colorSwath" style="background: #F0FFFF;"></span>
*
* @constant
* @type {Color}
*/
Color.AZURE = freezeObject(Color.fromCssColorString('#F0FFFF'));
/**
* An immutable Color instance initialized to CSS color #F5F5DC
* <span class="colorSwath" style="background: #F5F5DC;"></span>
*
* @constant
* @type {Color}
*/
Color.BEIGE = freezeObject(Color.fromCssColorString('#F5F5DC'));
/**
* An immutable Color instance initialized to CSS color #FFE4C4
* <span class="colorSwath" style="background: #FFE4C4;"></span>
*
* @constant
* @type {Color}
*/
Color.BISQUE = freezeObject(Color.fromCssColorString('#FFE4C4'));
/**
* An immutable Color instance initialized to CSS color #000000
* <span class="colorSwath" style="background: #000000;"></span>
*
* @constant
* @type {Color}
*/
Color.BLACK = freezeObject(Color.fromCssColorString('#000000'));
/**
* An immutable Color instance initialized to CSS color #FFEBCD
* <span class="colorSwath" style="background: #FFEBCD;"></span>
*
* @constant
* @type {Color}
*/
Color.BLANCHEDALMOND = freezeObject(Color.fromCssColorString('#FFEBCD'));
/**
* An immutable Color instance initialized to CSS color #0000FF
* <span class="colorSwath" style="background: #0000FF;"></span>
*
* @constant
* @type {Color}
*/
Color.BLUE = freezeObject(Color.fromCssColorString('#0000FF'));
/**
* An immutable Color instance initialized to CSS color #8A2BE2
* <span class="colorSwath" style="background: #8A2BE2;"></span>
*
* @constant
* @type {Color}
*/
Color.BLUEVIOLET = freezeObject(Color.fromCssColorString('#8A2BE2'));
/**
* An immutable Color instance initialized to CSS color #A52A2A
* <span class="colorSwath" style="background: #A52A2A;"></span>
*
* @constant
* @type {Color}
*/
Color.BROWN = freezeObject(Color.fromCssColorString('#A52A2A'));
/**
* An immutable Color instance initialized to CSS color #DEB887
* <span class="colorSwath" style="background: #DEB887;"></span>
*
* @constant
* @type {Color}
*/
Color.BURLYWOOD = freezeObject(Color.fromCssColorString('#DEB887'));
/**
* An immutable Color instance initialized to CSS color #5F9EA0
* <span class="colorSwath" style="background: #5F9EA0;"></span>
*
* @constant
* @type {Color}
*/
Color.CADETBLUE = freezeObject(Color.fromCssColorString('#5F9EA0'));
/**
* An immutable Color instance initialized to CSS color #7FFF00
* <span class="colorSwath" style="background: #7FFF00;"></span>
*
* @constant
* @type {Color}
*/
Color.CHARTREUSE = freezeObject(Color.fromCssColorString('#7FFF00'));
/**
* An immutable Color instance initialized to CSS color #D2691E
* <span class="colorSwath" style="background: #D2691E;"></span>
*
* @constant
* @type {Color}
*/
Color.CHOCOLATE = freezeObject(Color.fromCssColorString('#D2691E'));
/**
* An immutable Color instance initialized to CSS color #FF7F50
* <span class="colorSwath" style="background: #FF7F50;"></span>
*
* @constant
* @type {Color}
*/
Color.CORAL = freezeObject(Color.fromCssColorString('#FF7F50'));
/**
* An immutable Color instance initialized to CSS color #6495ED
* <span class="colorSwath" style="background: #6495ED;"></span>
*
* @constant
* @type {Color}
*/
Color.CORNFLOWERBLUE = freezeObject(Color.fromCssColorString('#6495ED'));
/**
* An immutable Color instance initialized to CSS color #FFF8DC
* <span class="colorSwath" style="background: #FFF8DC;"></span>
*
* @constant
* @type {Color}
*/
Color.CORNSILK = freezeObject(Color.fromCssColorString('#FFF8DC'));
/**
* An immutable Color instance initialized to CSS color #DC143C
* <span class="colorSwath" style="background: #DC143C;"></span>
*
* @constant
* @type {Color}
*/
Color.CRIMSON = freezeObject(Color.fromCssColorString('#DC143C'));
/**
* An immutable Color instance initialized to CSS color #00FFFF
* <span class="colorSwath" style="background: #00FFFF;"></span>
*
* @constant
* @type {Color}
*/
Color.CYAN = freezeObject(Color.fromCssColorString('#00FFFF'));
/**
* An immutable Color instance initialized to CSS color #00008B
* <span class="colorSwath" style="background: #00008B;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKBLUE = freezeObject(Color.fromCssColorString('#00008B'));
/**
* An immutable Color instance initialized to CSS color #008B8B
* <span class="colorSwath" style="background: #008B8B;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKCYAN = freezeObject(Color.fromCssColorString('#008B8B'));
/**
* An immutable Color instance initialized to CSS color #B8860B
* <span class="colorSwath" style="background: #B8860B;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKGOLDENROD = freezeObject(Color.fromCssColorString('#B8860B'));
/**
* An immutable Color instance initialized to CSS color #A9A9A9
* <span class="colorSwath" style="background: #A9A9A9;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKGRAY = freezeObject(Color.fromCssColorString('#A9A9A9'));
/**
* An immutable Color instance initialized to CSS color #006400
* <span class="colorSwath" style="background: #006400;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKGREEN = freezeObject(Color.fromCssColorString('#006400'));
/**
* An immutable Color instance initialized to CSS color #A9A9A9
* <span class="colorSwath" style="background: #A9A9A9;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKGREY = Color.DARKGRAY;
/**
* An immutable Color instance initialized to CSS color #BDB76B
* <span class="colorSwath" style="background: #BDB76B;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKKHAKI = freezeObject(Color.fromCssColorString('#BDB76B'));
/**
* An immutable Color instance initialized to CSS color #8B008B
* <span class="colorSwath" style="background: #8B008B;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKMAGENTA = freezeObject(Color.fromCssColorString('#8B008B'));
/**
* An immutable Color instance initialized to CSS color #556B2F
* <span class="colorSwath" style="background: #556B2F;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKOLIVEGREEN = freezeObject(Color.fromCssColorString('#556B2F'));
/**
* An immutable Color instance initialized to CSS color #FF8C00
* <span class="colorSwath" style="background: #FF8C00;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKORANGE = freezeObject(Color.fromCssColorString('#FF8C00'));
/**
* An immutable Color instance initialized to CSS color #9932CC
* <span class="colorSwath" style="background: #9932CC;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKORCHID = freezeObject(Color.fromCssColorString('#9932CC'));
/**
* An immutable Color instance initialized to CSS color #8B0000
* <span class="colorSwath" style="background: #8B0000;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKRED = freezeObject(Color.fromCssColorString('#8B0000'));
/**
* An immutable Color instance initialized to CSS color #E9967A
* <span class="colorSwath" style="background: #E9967A;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKSALMON = freezeObject(Color.fromCssColorString('#E9967A'));
/**
* An immutable Color instance initialized to CSS color #8FBC8F
* <span class="colorSwath" style="background: #8FBC8F;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKSEAGREEN = freezeObject(Color.fromCssColorString('#8FBC8F'));
/**
* An immutable Color instance initialized to CSS color #483D8B
* <span class="colorSwath" style="background: #483D8B;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKSLATEBLUE = freezeObject(Color.fromCssColorString('#483D8B'));
/**
* An immutable Color instance initialized to CSS color #2F4F4F
* <span class="colorSwath" style="background: #2F4F4F;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKSLATEGRAY = freezeObject(Color.fromCssColorString('#2F4F4F'));
/**
* An immutable Color instance initialized to CSS color #2F4F4F
* <span class="colorSwath" style="background: #2F4F4F;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKSLATEGREY = Color.DARKSLATEGRAY;
/**
* An immutable Color instance initialized to CSS color #00CED1
* <span class="colorSwath" style="background: #00CED1;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKTURQUOISE = freezeObject(Color.fromCssColorString('#00CED1'));
/**
* An immutable Color instance initialized to CSS color #9400D3
* <span class="colorSwath" style="background: #9400D3;"></span>
*
* @constant
* @type {Color}
*/
Color.DARKVIOLET = freezeObject(Color.fromCssColorString('#9400D3'));
/**
* An immutable Color instance initialized to CSS color #FF1493
* <span class="colorSwath" style="background: #FF1493;"></span>
*
* @constant
* @type {Color}
*/
Color.DEEPPINK = freezeObject(Color.fromCssColorString('#FF1493'));
/**
* An immutable Color instance initialized to CSS color #00BFFF
* <span class="colorSwath" style="background: #00BFFF;"></span>
*
* @constant
* @type {Color}
*/
Color.DEEPSKYBLUE = freezeObject(Color.fromCssColorString('#00BFFF'));
/**
* An immutable Color instance initialized to CSS color #696969
* <span class="colorSwath" style="background: #696969;"></span>
*
* @constant
* @type {Color}
*/
Color.DIMGRAY = freezeObject(Color.fromCssColorString('#696969'));
/**
* An immutable Color instance initialized to CSS color #696969
* <span class="colorSwath" style="background: #696969;"></span>
*
* @constant
* @type {Color}
*/
Color.DIMGREY = Color.DIMGRAY;
/**
* An immutable Color instance initialized to CSS color #1E90FF
* <span class="colorSwath" style="background: #1E90FF;"></span>
*
* @constant
* @type {Color}
*/
Color.DODGERBLUE = freezeObject(Color.fromCssColorString('#1E90FF'));
/**
* An immutable Color instance initialized to CSS color #B22222
* <span class="colorSwath" style="background: #B22222;"></span>
*
* @constant
* @type {Color}
*/
Color.FIREBRICK = freezeObject(Color.fromCssColorString('#B22222'));
/**
* An immutable Color instance initialized to CSS color #FFFAF0
* <span class="colorSwath" style="background: #FFFAF0;"></span>
*
* @constant
* @type {Color}
*/
Color.FLORALWHITE = freezeObject(Color.fromCssColorString('#FFFAF0'));
/**
* An immutable Color instance initialized to CSS color #228B22
* <span class="colorSwath" style="background: #228B22;"></span>
*
* @constant
* @type {Color}
*/
Color.FORESTGREEN = freezeObject(Color.fromCssColorString('#228B22'));
/**
* An immutable Color instance initialized to CSS color #FF00FF
* <span class="colorSwath" style="background: #FF00FF;"></span>
*
* @constant
* @type {Color}
*/
Color.FUCHSIA = freezeObject(Color.fromCssColorString('#FF00FF'));
/**
* An immutable Color instance initialized to CSS color #DCDCDC
* <span class="colorSwath" style="background: #DCDCDC;"></span>
*
* @constant
* @type {Color}
*/
Color.GAINSBORO = freezeObject(Color.fromCssColorString('#DCDCDC'));
/**
* An immutable Color instance initialized to CSS color #F8F8FF
* <span class="colorSwath" style="background: #F8F8FF;"></span>
*
* @constant
* @type {Color}
*/
Color.GHOSTWHITE = freezeObject(Color.fromCssColorString('#F8F8FF'));
/**
* An immutable Color instance initialized to CSS color #FFD700
* <span class="colorSwath" style="background: #FFD700;"></span>
*
* @constant
* @type {Color}
*/
Color.GOLD = freezeObject(Color.fromCssColorString('#FFD700'));
/**
* An immutable Color instance initialized to CSS color #DAA520
* <span class="colorSwath" style="background: #DAA520;"></span>
*
* @constant
* @type {Color}
*/
Color.GOLDENROD = freezeObject(Color.fromCssColorString('#DAA520'));
/**
* An immutable Color instance initialized to CSS color #808080
* <span class="colorSwath" style="background: #808080;"></span>
*
* @constant
* @type {Color}
*/
Color.GRAY = freezeObject(Color.fromCssColorString('#808080'));
/**
* An immutable Color instance initialized to CSS color #008000
* <span class="colorSwath" style="background: #008000;"></span>
*
* @constant
* @type {Color}
*/
Color.GREEN = freezeObject(Color.fromCssColorString('#008000'));
/**
* An immutable Color instance initialized to CSS color #ADFF2F
* <span class="colorSwath" style="background: #ADFF2F;"></span>
*
* @constant
* @type {Color}
*/
Color.GREENYELLOW = freezeObject(Color.fromCssColorString('#ADFF2F'));
/**
* An immutable Color instance initialized to CSS color #808080
* <span class="colorSwath" style="background: #808080;"></span>
*
* @constant
* @type {Color}
*/
Color.GREY = Color.GRAY;
/**
* An immutable Color instance initialized to CSS color #F0FFF0
* <span class="colorSwath" style="background: #F0FFF0;"></span>
*
* @constant
* @type {Color}
*/
Color.HONEYDEW = freezeObject(Color.fromCssColorString('#F0FFF0'));
/**
* An immutable Color instance initialized to CSS color #FF69B4
* <span class="colorSwath" style="background: #FF69B4;"></span>
*
* @constant
* @type {Color}
*/
Color.HOTPINK = freezeObject(Color.fromCssColorString('#FF69B4'));
/**
* An immutable Color instance initialized to CSS color #CD5C5C
* <span class="colorSwath" style="background: #CD5C5C;"></span>
*
* @constant
* @type {Color}
*/
Color.INDIANRED = freezeObject(Color.fromCssColorString('#CD5C5C'));
/**
* An immutable Color instance initialized to CSS color #4B0082
* <span class="colorSwath" style="background: #4B0082;"></span>
*
* @constant
* @type {Color}
*/
Color.INDIGO = freezeObject(Color.fromCssColorString('#4B0082'));
/**
* An immutable Color instance initialized to CSS color #FFFFF0
* <span class="colorSwath" style="background: #FFFFF0;"></span>
*
* @constant
* @type {Color}
*/
Color.IVORY = freezeObject(Color.fromCssColorString('#FFFFF0'));
/**
* An immutable Color instance initialized to CSS color #F0E68C
* <span class="colorSwath" style="background: #F0E68C;"></span>
*
* @constant
* @type {Color}
*/
Color.KHAKI = freezeObject(Color.fromCssColorString('#F0E68C'));
/**
* An immutable Color instance initialized to CSS color #E6E6FA
* <span class="colorSwath" style="background: #E6E6FA;"></span>
*
* @constant
* @type {Color}
*/
Color.LAVENDER = freezeObject(Color.fromCssColorString('#E6E6FA'));
/**
* An immutable Color instance initialized to CSS color #FFF0F5
* <span class="colorSwath" style="background: #FFF0F5;"></span>
*
* @constant
* @type {Color}
*/
Color.LAVENDAR_BLUSH = freezeObject(Color.fromCssColorString('#FFF0F5'));
/**
* An immutable Color instance initialized to CSS color #7CFC00
* <span class="colorSwath" style="background: #7CFC00;"></span>
*
* @constant
* @type {Color}
*/
Color.LAWNGREEN = freezeObject(Color.fromCssColorString('#7CFC00'));
/**
* An immutable Color instance initialized to CSS color #FFFACD
* <span class="colorSwath" style="background: #FFFACD;"></span>
*
* @constant
* @type {Color}
*/
Color.LEMONCHIFFON = freezeObject(Color.fromCssColorString('#FFFACD'));
/**
* An immutable Color instance initialized to CSS color #ADD8E6
* <span class="colorSwath" style="background: #ADD8E6;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTBLUE = freezeObject(Color.fromCssColorString('#ADD8E6'));
/**
* An immutable Color instance initialized to CSS color #F08080
* <span class="colorSwath" style="background: #F08080;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTCORAL = freezeObject(Color.fromCssColorString('#F08080'));
/**
* An immutable Color instance initialized to CSS color #E0FFFF
* <span class="colorSwath" style="background: #E0FFFF;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTCYAN = freezeObject(Color.fromCssColorString('#E0FFFF'));
/**
* An immutable Color instance initialized to CSS color #FAFAD2
* <span class="colorSwath" style="background: #FAFAD2;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTGOLDENRODYELLOW = freezeObject(Color.fromCssColorString('#FAFAD2'));
/**
* An immutable Color instance initialized to CSS color #D3D3D3
* <span class="colorSwath" style="background: #D3D3D3;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTGRAY = freezeObject(Color.fromCssColorString('#D3D3D3'));
/**
* An immutable Color instance initialized to CSS color #90EE90
* <span class="colorSwath" style="background: #90EE90;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTGREEN = freezeObject(Color.fromCssColorString('#90EE90'));
/**
* An immutable Color instance initialized to CSS color #D3D3D3
* <span class="colorSwath" style="background: #D3D3D3;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTGREY = Color.LIGHTGRAY;
/**
* An immutable Color instance initialized to CSS color #FFB6C1
* <span class="colorSwath" style="background: #FFB6C1;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTPINK = freezeObject(Color.fromCssColorString('#FFB6C1'));
/**
* An immutable Color instance initialized to CSS color #20B2AA
* <span class="colorSwath" style="background: #20B2AA;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTSEAGREEN = freezeObject(Color.fromCssColorString('#20B2AA'));
/**
* An immutable Color instance initialized to CSS color #87CEFA
* <span class="colorSwath" style="background: #87CEFA;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTSKYBLUE = freezeObject(Color.fromCssColorString('#87CEFA'));
/**
* An immutable Color instance initialized to CSS color #778899
* <span class="colorSwath" style="background: #778899;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTSLATEGRAY = freezeObject(Color.fromCssColorString('#778899'));
/**
* An immutable Color instance initialized to CSS color #778899
* <span class="colorSwath" style="background: #778899;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTSLATEGREY = Color.LIGHTSLATEGRAY;
/**
* An immutable Color instance initialized to CSS color #B0C4DE
* <span class="colorSwath" style="background: #B0C4DE;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTSTEELBLUE = freezeObject(Color.fromCssColorString('#B0C4DE'));
/**
* An immutable Color instance initialized to CSS color #FFFFE0
* <span class="colorSwath" style="background: #FFFFE0;"></span>
*
* @constant
* @type {Color}
*/
Color.LIGHTYELLOW = freezeObject(Color.fromCssColorString('#FFFFE0'));
/**
* An immutable Color instance initialized to CSS color #00FF00
* <span class="colorSwath" style="background: #00FF00;"></span>
*
* @constant
* @type {Color}
*/
Color.LIME = freezeObject(Color.fromCssColorString('#00FF00'));
/**
* An immutable Color instance initialized to CSS color #32CD32
* <span class="colorSwath" style="background: #32CD32;"></span>
*
* @constant
* @type {Color}
*/
Color.LIMEGREEN = freezeObject(Color.fromCssColorString('#32CD32'));
/**
* An immutable Color instance initialized to CSS color #FAF0E6
* <span class="colorSwath" style="background: #FAF0E6;"></span>
*
* @constant
* @type {Color}
*/
Color.LINEN = freezeObject(Color.fromCssColorString('#FAF0E6'));
/**
* An immutable Color instance initialized to CSS color #FF00FF
* <span class="colorSwath" style="background: #FF00FF;"></span>
*
* @constant
* @type {Color}
*/
Color.MAGENTA = freezeObject(Color.fromCssColorString('#FF00FF'));
/**
* An immutable Color instance initialized to CSS color #800000
* <span class="colorSwath" style="background: #800000;"></span>
*
* @constant
* @type {Color}
*/
Color.MAROON = freezeObject(Color.fromCssColorString('#800000'));
/**
* An immutable Color instance initialized to CSS color #66CDAA
* <span class="colorSwath" style="background: #66CDAA;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMAQUAMARINE = freezeObject(Color.fromCssColorString('#66CDAA'));
/**
* An immutable Color instance initialized to CSS color #0000CD
* <span class="colorSwath" style="background: #0000CD;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMBLUE = freezeObject(Color.fromCssColorString('#0000CD'));
/**
* An immutable Color instance initialized to CSS color #BA55D3
* <span class="colorSwath" style="background: #BA55D3;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMORCHID = freezeObject(Color.fromCssColorString('#BA55D3'));
/**
* An immutable Color instance initialized to CSS color #9370DB
* <span class="colorSwath" style="background: #9370DB;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMPURPLE = freezeObject(Color.fromCssColorString('#9370DB'));
/**
* An immutable Color instance initialized to CSS color #3CB371
* <span class="colorSwath" style="background: #3CB371;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMSEAGREEN = freezeObject(Color.fromCssColorString('#3CB371'));
/**
* An immutable Color instance initialized to CSS color #7B68EE
* <span class="colorSwath" style="background: #7B68EE;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMSLATEBLUE = freezeObject(Color.fromCssColorString('#7B68EE'));
/**
* An immutable Color instance initialized to CSS color #00FA9A
* <span class="colorSwath" style="background: #00FA9A;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMSPRINGGREEN = freezeObject(Color.fromCssColorString('#00FA9A'));
/**
* An immutable Color instance initialized to CSS color #48D1CC
* <span class="colorSwath" style="background: #48D1CC;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMTURQUOISE = freezeObject(Color.fromCssColorString('#48D1CC'));
/**
* An immutable Color instance initialized to CSS color #C71585
* <span class="colorSwath" style="background: #C71585;"></span>
*
* @constant
* @type {Color}
*/
Color.MEDIUMVIOLETRED = freezeObject(Color.fromCssColorString('#C71585'));
/**
* An immutable Color instance initialized to CSS color #191970
* <span class="colorSwath" style="background: #191970;"></span>
*
* @constant
* @type {Color}
*/
Color.MIDNIGHTBLUE = freezeObject(Color.fromCssColorString('#191970'));
/**
* An immutable Color instance initialized to CSS color #F5FFFA
* <span class="colorSwath" style="background: #F5FFFA;"></span>
*
* @constant
* @type {Color}
*/
Color.MINTCREAM = freezeObject(Color.fromCssColorString('#F5FFFA'));
/**
* An immutable Color instance initialized to CSS color #FFE4E1
* <span class="colorSwath" style="background: #FFE4E1;"></span>
*
* @constant
* @type {Color}
*/
Color.MISTYROSE = freezeObject(Color.fromCssColorString('#FFE4E1'));
/**
* An immutable Color instance initialized to CSS color #FFE4B5
* <span class="colorSwath" style="background: #FFE4B5;"></span>
*
* @constant
* @type {Color}
*/
Color.MOCCASIN = freezeObject(Color.fromCssColorString('#FFE4B5'));
/**
* An immutable Color instance initialized to CSS color #FFDEAD
* <span class="colorSwath" style="background: #FFDEAD;"></span>
*
* @constant
* @type {Color}
*/
Color.NAVAJOWHITE = freezeObject(Color.fromCssColorString('#FFDEAD'));
/**
* An immutable Color instance initialized to CSS color #000080
* <span class="colorSwath" style="background: #000080;"></span>
*
* @constant
* @type {Color}
*/
Color.NAVY = freezeObject(Color.fromCssColorString('#000080'));
/**
* An immutable Color instance initialized to CSS color #FDF5E6
* <span class="colorSwath" style="background: #FDF5E6;"></span>
*
* @constant
* @type {Color}
*/
Color.OLDLACE = freezeObject(Color.fromCssColorString('#FDF5E6'));
/**
* An immutable Color instance initialized to CSS color #808000
* <span class="colorSwath" style="background: #808000;"></span>
*
* @constant
* @type {Color}
*/
Color.OLIVE = freezeObject(Color.fromCssColorString('#808000'));
/**
* An immutable Color instance initialized to CSS color #6B8E23
* <span class="colorSwath" style="background: #6B8E23;"></span>
*
* @constant
* @type {Color}
*/
Color.OLIVEDRAB = freezeObject(Color.fromCssColorString('#6B8E23'));
/**
* An immutable Color instance initialized to CSS color #FFA500
* <span class="colorSwath" style="background: #FFA500;"></span>
*
* @constant
* @type {Color}
*/
Color.ORANGE = freezeObject(Color.fromCssColorString('#FFA500'));
/**
* An immutable Color instance initialized to CSS color #FF4500
* <span class="colorSwath" style="background: #FF4500;"></span>
*
* @constant
* @type {Color}
*/
Color.ORANGERED = freezeObject(Color.fromCssColorString('#FF4500'));
/**
* An immutable Color instance initialized to CSS color #DA70D6
* <span class="colorSwath" style="background: #DA70D6;"></span>
*
* @constant
* @type {Color}
*/
Color.ORCHID = freezeObject(Color.fromCssColorString('#DA70D6'));
/**
* An immutable Color instance initialized to CSS color #EEE8AA
* <span class="colorSwath" style="background: #EEE8AA;"></span>
*
* @constant
* @type {Color}
*/
Color.PALEGOLDENROD = freezeObject(Color.fromCssColorString('#EEE8AA'));
/**
* An immutable Color instance initialized to CSS color #98FB98
* <span class="colorSwath" style="background: #98FB98;"></span>
*
* @constant
* @type {Color}
*/
Color.PALEGREEN = freezeObject(Color.fromCssColorString('#98FB98'));
/**
* An immutable Color instance initialized to CSS color #AFEEEE
* <span class="colorSwath" style="background: #AFEEEE;"></span>
*
* @constant
* @type {Color}
*/
Color.PALETURQUOISE = freezeObject(Color.fromCssColorString('#AFEEEE'));
/**
* An immutable Color instance initialized to CSS color #DB7093
* <span class="colorSwath" style="background: #DB7093;"></span>
*
* @constant
* @type {Color}
*/
Color.PALEVIOLETRED = freezeObject(Color.fromCssColorString('#DB7093'));
/**
* An immutable Color instance initialized to CSS color #FFEFD5
* <span class="colorSwath" style="background: #FFEFD5;"></span>
*
* @constant
* @type {Color}
*/
Color.PAPAYAWHIP = freezeObject(Color.fromCssColorString('#FFEFD5'));
/**
* An immutable Color instance initialized to CSS color #FFDAB9
* <span class="colorSwath" style="background: #FFDAB9;"></span>
*
* @constant
* @type {Color}
*/
Color.PEACHPUFF = freezeObject(Color.fromCssColorString('#FFDAB9'));
/**
* An immutable Color instance initialized to CSS color #CD853F
* <span class="colorSwath" style="background: #CD853F;"></span>
*
* @constant
* @type {Color}
*/
Color.PERU = freezeObject(Color.fromCssColorString('#CD853F'));
/**
* An immutable Color instance initialized to CSS color #FFC0CB
* <span class="colorSwath" style="background: #FFC0CB;"></span>
*
* @constant
* @type {Color}
*/
Color.PINK = freezeObject(Color.fromCssColorString('#FFC0CB'));
/**
* An immutable Color instance initialized to CSS color #DDA0DD
* <span class="colorSwath" style="background: #DDA0DD;"></span>
*
* @constant
* @type {Color}
*/
Color.PLUM = freezeObject(Color.fromCssColorString('#DDA0DD'));
/**
* An immutable Color instance initialized to CSS color #B0E0E6
* <span class="colorSwath" style="background: #B0E0E6;"></span>
*
* @constant
* @type {Color}
*/
Color.POWDERBLUE = freezeObject(Color.fromCssColorString('#B0E0E6'));
/**
* An immutable Color instance initialized to CSS color #800080
* <span class="colorSwath" style="background: #800080;"></span>
*
* @constant
* @type {Color}
*/
Color.PURPLE = freezeObject(Color.fromCssColorString('#800080'));
/**
* An immutable Color instance initialized to CSS color #FF0000
* <span class="colorSwath" style="background: #FF0000;"></span>
*
* @constant
* @type {Color}
*/
Color.RED = freezeObject(Color.fromCssColorString('#FF0000'));
/**
* An immutable Color instance initialized to CSS color #BC8F8F
* <span class="colorSwath" style="background: #BC8F8F;"></span>
*
* @constant
* @type {Color}
*/
Color.ROSYBROWN = freezeObject(Color.fromCssColorString('#BC8F8F'));
/**
* An immutable Color instance initialized to CSS color #4169E1
* <span class="colorSwath" style="background: #4169E1;"></span>
*
* @constant
* @type {Color}
*/
Color.ROYALBLUE = freezeObject(Color.fromCssColorString('#4169E1'));
/**
* An immutable Color instance initialized to CSS color #8B4513
* <span class="colorSwath" style="background: #8B4513;"></span>
*
* @constant
* @type {Color}
*/
Color.SADDLEBROWN = freezeObject(Color.fromCssColorString('#8B4513'));
/**
* An immutable Color instance initialized to CSS color #FA8072
* <span class="colorSwath" style="background: #FA8072;"></span>
*
* @constant
* @type {Color}
*/
Color.SALMON = freezeObject(Color.fromCssColorString('#FA8072'));
/**
* An immutable Color instance initialized to CSS color #F4A460
* <span class="colorSwath" style="background: #F4A460;"></span>
*
* @constant
* @type {Color}
*/
Color.SANDYBROWN = freezeObject(Color.fromCssColorString('#F4A460'));
/**
* An immutable Color instance initialized to CSS color #2E8B57
* <span class="colorSwath" style="background: #2E8B57;"></span>
*
* @constant
* @type {Color}
*/
Color.SEAGREEN = freezeObject(Color.fromCssColorString('#2E8B57'));
/**
* An immutable Color instance initialized to CSS color #FFF5EE
* <span class="colorSwath" style="background: #FFF5EE;"></span>
*
* @constant
* @type {Color}
*/
Color.SEASHELL = freezeObject(Color.fromCssColorString('#FFF5EE'));
/**
* An immutable Color instance initialized to CSS color #A0522D
* <span class="colorSwath" style="background: #A0522D;"></span>
*
* @constant
* @type {Color}
*/
Color.SIENNA = freezeObject(Color.fromCssColorString('#A0522D'));
/**
* An immutable Color instance initialized to CSS color #C0C0C0
* <span class="colorSwath" style="background: #C0C0C0;"></span>
*
* @constant
* @type {Color}
*/
Color.SILVER = freezeObject(Color.fromCssColorString('#C0C0C0'));
/**
* An immutable Color instance initialized to CSS color #87CEEB
* <span class="colorSwath" style="background: #87CEEB;"></span>
*
* @constant
* @type {Color}
*/
Color.SKYBLUE = freezeObject(Color.fromCssColorString('#87CEEB'));
/**
* An immutable Color instance initialized to CSS color #6A5ACD
* <span class="colorSwath" style="background: #6A5ACD;"></span>
*
* @constant
* @type {Color}
*/
Color.SLATEBLUE = freezeObject(Color.fromCssColorString('#6A5ACD'));
/**
* An immutable Color instance initialized to CSS color #708090
* <span class="colorSwath" style="background: #708090;"></span>
*
* @constant
* @type {Color}
*/
Color.SLATEGRAY = freezeObject(Color.fromCssColorString('#708090'));
/**
* An immutable Color instance initialized to CSS color #708090
* <span class="colorSwath" style="background: #708090;"></span>
*
* @constant
* @type {Color}
*/
Color.SLATEGREY = Color.SLATEGRAY;
/**
* An immutable Color instance initialized to CSS color #FFFAFA
* <span class="colorSwath" style="background: #FFFAFA;"></span>
*
* @constant
* @type {Color}
*/
Color.SNOW = freezeObject(Color.fromCssColorString('#FFFAFA'));
/**
* An immutable Color instance initialized to CSS color #00FF7F
* <span class="colorSwath" style="background: #00FF7F;"></span>
*
* @constant
* @type {Color}
*/
Color.SPRINGGREEN = freezeObject(Color.fromCssColorString('#00FF7F'));
/**
* An immutable Color instance initialized to CSS color #4682B4
* <span class="colorSwath" style="background: #4682B4;"></span>
*
* @constant
* @type {Color}
*/
Color.STEELBLUE = freezeObject(Color.fromCssColorString('#4682B4'));
/**
* An immutable Color instance initialized to CSS color #D2B48C
* <span class="colorSwath" style="background: #D2B48C;"></span>
*
* @constant
* @type {Color}
*/
Color.TAN = freezeObject(Color.fromCssColorString('#D2B48C'));
/**
* An immutable Color instance initialized to CSS color #008080
* <span class="colorSwath" style="background: #008080;"></span>
*
* @constant
* @type {Color}
*/
Color.TEAL = freezeObject(Color.fromCssColorString('#008080'));
/**
* An immutable Color instance initialized to CSS color #D8BFD8
* <span class="colorSwath" style="background: #D8BFD8;"></span>
*
* @constant
* @type {Color}
*/
Color.THISTLE = freezeObject(Color.fromCssColorString('#D8BFD8'));
/**
* An immutable Color instance initialized to CSS color #FF6347
* <span class="colorSwath" style="background: #FF6347;"></span>
*
* @constant
* @type {Color}
*/
Color.TOMATO = freezeObject(Color.fromCssColorString('#FF6347'));
/**
* An immutable Color instance initialized to CSS color #40E0D0
* <span class="colorSwath" style="background: #40E0D0;"></span>
*
* @constant
* @type {Color}
*/
Color.TURQUOISE = freezeObject(Color.fromCssColorString('#40E0D0'));
/**
* An immutable Color instance initialized to CSS color #EE82EE
* <span class="colorSwath" style="background: #EE82EE;"></span>
*
* @constant
* @type {Color}
*/
Color.VIOLET = freezeObject(Color.fromCssColorString('#EE82EE'));
/**
* An immutable Color instance initialized to CSS color #F5DEB3
* <span class="colorSwath" style="background: #F5DEB3;"></span>
*
* @constant
* @type {Color}
*/
Color.WHEAT = freezeObject(Color.fromCssColorString('#F5DEB3'));
/**
* An immutable Color instance initialized to CSS color #FFFFFF
* <span class="colorSwath" style="background: #FFFFFF;"></span>
*
* @constant
* @type {Color}
*/
Color.WHITE = freezeObject(Color.fromCssColorString('#FFFFFF'));
/**
* An immutable Color instance initialized to CSS color #F5F5F5
* <span class="colorSwath" style="background: #F5F5F5;"></span>
*
* @constant
* @type {Color}
*/
Color.WHITESMOKE = freezeObject(Color.fromCssColorString('#F5F5F5'));
/**
* An immutable Color instance initialized to CSS color #FFFF00
* <span class="colorSwath" style="background: #FFFF00;"></span>
*
* @constant
* @type {Color}
*/
Color.YELLOW = freezeObject(Color.fromCssColorString('#FFFF00'));
/**
* An immutable Color instance initialized to CSS color #9ACD32
* <span class="colorSwath" style="background: #9ACD32;"></span>
*
* @constant
* @type {Color}
*/
Color.YELLOWGREEN = freezeObject(Color.fromCssColorString('#9ACD32'));
/**
* An immutable Color instance initialized to CSS transparent.
* <span class="colorSwath" style="background: transparent;"></span>
*
* @constant
* @type {Color}
*/
Color.TRANSPARENT = freezeObject(new Color(0, 0, 0, 0));
return Color;
});
/*global define*/
define('Core/WebGLConstants',[
'./freezeObject'
], function(
freezeObject) {
'use strict';
/**
* Enum containing WebGL Constant values by name.
* for use without an active WebGL context, or in cases where certain constants are unavailable using the WebGL context
* (For example, in [Safari 9]{@link https://github.com/AnalyticalGraphicsInc/cesium/issues/2989}).
*
* These match the constants from the [WebGL 1.0]{@link https://www.khronos.org/registry/webgl/specs/latest/1.0/}
* and [WebGL 2.0]{@link https://www.khronos.org/registry/webgl/specs/latest/2.0/}
* specifications.
*
* @exports WebGLConstants
*/
var WebGLConstants = {
DEPTH_BUFFER_BIT : 0x00000100,
STENCIL_BUFFER_BIT : 0x00000400,
COLOR_BUFFER_BIT : 0x00004000,
POINTS : 0x0000,
LINES : 0x0001,
LINE_LOOP : 0x0002,
LINE_STRIP : 0x0003,
TRIANGLES : 0x0004,
TRIANGLE_STRIP : 0x0005,
TRIANGLE_FAN : 0x0006,
ZERO : 0,
ONE : 1,
SRC_COLOR : 0x0300,
ONE_MINUS_SRC_COLOR : 0x0301,
SRC_ALPHA : 0x0302,
ONE_MINUS_SRC_ALPHA : 0x0303,
DST_ALPHA : 0x0304,
ONE_MINUS_DST_ALPHA : 0x0305,
DST_COLOR : 0x0306,
ONE_MINUS_DST_COLOR : 0x0307,
SRC_ALPHA_SATURATE : 0x0308,
FUNC_ADD : 0x8006,
BLEND_EQUATION : 0x8009,
BLEND_EQUATION_RGB : 0x8009, // same as BLEND_EQUATION
BLEND_EQUATION_ALPHA : 0x883D,
FUNC_SUBTRACT : 0x800A,
FUNC_REVERSE_SUBTRACT : 0x800B,
BLEND_DST_RGB : 0x80C8,
BLEND_SRC_RGB : 0x80C9,
BLEND_DST_ALPHA : 0x80CA,
BLEND_SRC_ALPHA : 0x80CB,
CONSTANT_COLOR : 0x8001,
ONE_MINUS_CONSTANT_COLOR : 0x8002,
CONSTANT_ALPHA : 0x8003,
ONE_MINUS_CONSTANT_ALPHA : 0x8004,
BLEND_COLOR : 0x8005,
ARRAY_BUFFER : 0x8892,
ELEMENT_ARRAY_BUFFER : 0x8893,
ARRAY_BUFFER_BINDING : 0x8894,
ELEMENT_ARRAY_BUFFER_BINDING : 0x8895,
STREAM_DRAW : 0x88E0,
STATIC_DRAW : 0x88E4,
DYNAMIC_DRAW : 0x88E8,
BUFFER_SIZE : 0x8764,
BUFFER_USAGE : 0x8765,
CURRENT_VERTEX_ATTRIB : 0x8626,
FRONT : 0x0404,
BACK : 0x0405,
FRONT_AND_BACK : 0x0408,
CULL_FACE : 0x0B44,
BLEND : 0x0BE2,
DITHER : 0x0BD0,
STENCIL_TEST : 0x0B90,
DEPTH_TEST : 0x0B71,
SCISSOR_TEST : 0x0C11,
POLYGON_OFFSET_FILL : 0x8037,
SAMPLE_ALPHA_TO_COVERAGE : 0x809E,
SAMPLE_COVERAGE : 0x80A0,
NO_ERROR : 0,
INVALID_ENUM : 0x0500,
INVALID_VALUE : 0x0501,
INVALID_OPERATION : 0x0502,
OUT_OF_MEMORY : 0x0505,
CW : 0x0900,
CCW : 0x0901,
LINE_WIDTH : 0x0B21,
ALIASED_POINT_SIZE_RANGE : 0x846D,
ALIASED_LINE_WIDTH_RANGE : 0x846E,
CULL_FACE_MODE : 0x0B45,
FRONT_FACE : 0x0B46,
DEPTH_RANGE : 0x0B70,
DEPTH_WRITEMASK : 0x0B72,
DEPTH_CLEAR_VALUE : 0x0B73,
DEPTH_FUNC : 0x0B74,
STENCIL_CLEAR_VALUE : 0x0B91,
STENCIL_FUNC : 0x0B92,
STENCIL_FAIL : 0x0B94,
STENCIL_PASS_DEPTH_FAIL : 0x0B95,
STENCIL_PASS_DEPTH_PASS : 0x0B96,
STENCIL_REF : 0x0B97,
STENCIL_VALUE_MASK : 0x0B93,
STENCIL_WRITEMASK : 0x0B98,
STENCIL_BACK_FUNC : 0x8800,
STENCIL_BACK_FAIL : 0x8801,
STENCIL_BACK_PASS_DEPTH_FAIL : 0x8802,
STENCIL_BACK_PASS_DEPTH_PASS : 0x8803,
STENCIL_BACK_REF : 0x8CA3,
STENCIL_BACK_VALUE_MASK : 0x8CA4,
STENCIL_BACK_WRITEMASK : 0x8CA5,
VIEWPORT : 0x0BA2,
SCISSOR_BOX : 0x0C10,
COLOR_CLEAR_VALUE : 0x0C22,
COLOR_WRITEMASK : 0x0C23,
UNPACK_ALIGNMENT : 0x0CF5,
PACK_ALIGNMENT : 0x0D05,
MAX_TEXTURE_SIZE : 0x0D33,
MAX_VIEWPORT_DIMS : 0x0D3A,
SUBPIXEL_BITS : 0x0D50,
RED_BITS : 0x0D52,
GREEN_BITS : 0x0D53,
BLUE_BITS : 0x0D54,
ALPHA_BITS : 0x0D55,
DEPTH_BITS : 0x0D56,
STENCIL_BITS : 0x0D57,
POLYGON_OFFSET_UNITS : 0x2A00,
POLYGON_OFFSET_FACTOR : 0x8038,
TEXTURE_BINDING_2D : 0x8069,
SAMPLE_BUFFERS : 0x80A8,
SAMPLES : 0x80A9,
SAMPLE_COVERAGE_VALUE : 0x80AA,
SAMPLE_COVERAGE_INVERT : 0x80AB,
COMPRESSED_TEXTURE_FORMATS : 0x86A3,
DONT_CARE : 0x1100,
FASTEST : 0x1101,
NICEST : 0x1102,
GENERATE_MIPMAP_HINT : 0x8192,
BYTE : 0x1400,
UNSIGNED_BYTE : 0x1401,
SHORT : 0x1402,
UNSIGNED_SHORT : 0x1403,
INT : 0x1404,
UNSIGNED_INT : 0x1405,
FLOAT : 0x1406,
DEPTH_COMPONENT : 0x1902,
ALPHA : 0x1906,
RGB : 0x1907,
RGBA : 0x1908,
LUMINANCE : 0x1909,
LUMINANCE_ALPHA : 0x190A,
UNSIGNED_SHORT_4_4_4_4 : 0x8033,
UNSIGNED_SHORT_5_5_5_1 : 0x8034,
UNSIGNED_SHORT_5_6_5 : 0x8363,
FRAGMENT_SHADER : 0x8B30,
VERTEX_SHADER : 0x8B31,
MAX_VERTEX_ATTRIBS : 0x8869,
MAX_VERTEX_UNIFORM_VECTORS : 0x8DFB,
MAX_VARYING_VECTORS : 0x8DFC,
MAX_COMBINED_TEXTURE_IMAGE_UNITS : 0x8B4D,
MAX_VERTEX_TEXTURE_IMAGE_UNITS : 0x8B4C,
MAX_TEXTURE_IMAGE_UNITS : 0x8872,
MAX_FRAGMENT_UNIFORM_VECTORS : 0x8DFD,
SHADER_TYPE : 0x8B4F,
DELETE_STATUS : 0x8B80,
LINK_STATUS : 0x8B82,
VALIDATE_STATUS : 0x8B83,
ATTACHED_SHADERS : 0x8B85,
ACTIVE_UNIFORMS : 0x8B86,
ACTIVE_ATTRIBUTES : 0x8B89,
SHADING_LANGUAGE_VERSION : 0x8B8C,
CURRENT_PROGRAM : 0x8B8D,
NEVER : 0x0200,
LESS : 0x0201,
EQUAL : 0x0202,
LEQUAL : 0x0203,
GREATER : 0x0204,
NOTEQUAL : 0x0205,
GEQUAL : 0x0206,
ALWAYS : 0x0207,
KEEP : 0x1E00,
REPLACE : 0x1E01,
INCR : 0x1E02,
DECR : 0x1E03,
INVERT : 0x150A,
INCR_WRAP : 0x8507,
DECR_WRAP : 0x8508,
VENDOR : 0x1F00,
RENDERER : 0x1F01,
VERSION : 0x1F02,
NEAREST : 0x2600,
LINEAR : 0x2601,
NEAREST_MIPMAP_NEAREST : 0x2700,
LINEAR_MIPMAP_NEAREST : 0x2701,
NEAREST_MIPMAP_LINEAR : 0x2702,
LINEAR_MIPMAP_LINEAR : 0x2703,
TEXTURE_MAG_FILTER : 0x2800,
TEXTURE_MIN_FILTER : 0x2801,
TEXTURE_WRAP_S : 0x2802,
TEXTURE_WRAP_T : 0x2803,
TEXTURE_2D : 0x0DE1,
TEXTURE : 0x1702,
TEXTURE_CUBE_MAP : 0x8513,
TEXTURE_BINDING_CUBE_MAP : 0x8514,
TEXTURE_CUBE_MAP_POSITIVE_X : 0x8515,
TEXTURE_CUBE_MAP_NEGATIVE_X : 0x8516,
TEXTURE_CUBE_MAP_POSITIVE_Y : 0x8517,
TEXTURE_CUBE_MAP_NEGATIVE_Y : 0x8518,
TEXTURE_CUBE_MAP_POSITIVE_Z : 0x8519,
TEXTURE_CUBE_MAP_NEGATIVE_Z : 0x851A,
MAX_CUBE_MAP_TEXTURE_SIZE : 0x851C,
TEXTURE0 : 0x84C0,
TEXTURE1 : 0x84C1,
TEXTURE2 : 0x84C2,
TEXTURE3 : 0x84C3,
TEXTURE4 : 0x84C4,
TEXTURE5 : 0x84C5,
TEXTURE6 : 0x84C6,
TEXTURE7 : 0x84C7,
TEXTURE8 : 0x84C8,
TEXTURE9 : 0x84C9,
TEXTURE10 : 0x84CA,
TEXTURE11 : 0x84CB,
TEXTURE12 : 0x84CC,
TEXTURE13 : 0x84CD,
TEXTURE14 : 0x84CE,
TEXTURE15 : 0x84CF,
TEXTURE16 : 0x84D0,
TEXTURE17 : 0x84D1,
TEXTURE18 : 0x84D2,
TEXTURE19 : 0x84D3,
TEXTURE20 : 0x84D4,
TEXTURE21 : 0x84D5,
TEXTURE22 : 0x84D6,
TEXTURE23 : 0x84D7,
TEXTURE24 : 0x84D8,
TEXTURE25 : 0x84D9,
TEXTURE26 : 0x84DA,
TEXTURE27 : 0x84DB,
TEXTURE28 : 0x84DC,
TEXTURE29 : 0x84DD,
TEXTURE30 : 0x84DE,
TEXTURE31 : 0x84DF,
ACTIVE_TEXTURE : 0x84E0,
REPEAT : 0x2901,
CLAMP_TO_EDGE : 0x812F,
MIRRORED_REPEAT : 0x8370,
FLOAT_VEC2 : 0x8B50,
FLOAT_VEC3 : 0x8B51,
FLOAT_VEC4 : 0x8B52,
INT_VEC2 : 0x8B53,
INT_VEC3 : 0x8B54,
INT_VEC4 : 0x8B55,
BOOL : 0x8B56,
BOOL_VEC2 : 0x8B57,
BOOL_VEC3 : 0x8B58,
BOOL_VEC4 : 0x8B59,
FLOAT_MAT2 : 0x8B5A,
FLOAT_MAT3 : 0x8B5B,
FLOAT_MAT4 : 0x8B5C,
SAMPLER_2D : 0x8B5E,
SAMPLER_CUBE : 0x8B60,
VERTEX_ATTRIB_ARRAY_ENABLED : 0x8622,
VERTEX_ATTRIB_ARRAY_SIZE : 0x8623,
VERTEX_ATTRIB_ARRAY_STRIDE : 0x8624,
VERTEX_ATTRIB_ARRAY_TYPE : 0x8625,
VERTEX_ATTRIB_ARRAY_NORMALIZED : 0x886A,
VERTEX_ATTRIB_ARRAY_POINTER : 0x8645,
VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : 0x889F,
IMPLEMENTATION_COLOR_READ_TYPE : 0x8B9A,
IMPLEMENTATION_COLOR_READ_FORMAT : 0x8B9B,
COMPILE_STATUS : 0x8B81,
LOW_FLOAT : 0x8DF0,
MEDIUM_FLOAT : 0x8DF1,
HIGH_FLOAT : 0x8DF2,
LOW_INT : 0x8DF3,
MEDIUM_INT : 0x8DF4,
HIGH_INT : 0x8DF5,
FRAMEBUFFER : 0x8D40,
RENDERBUFFER : 0x8D41,
RGBA4 : 0x8056,
RGB5_A1 : 0x8057,
RGB565 : 0x8D62,
DEPTH_COMPONENT16 : 0x81A5,
STENCIL_INDEX : 0x1901,
STENCIL_INDEX8 : 0x8D48,
DEPTH_STENCIL : 0x84F9,
RENDERBUFFER_WIDTH : 0x8D42,
RENDERBUFFER_HEIGHT : 0x8D43,
RENDERBUFFER_INTERNAL_FORMAT : 0x8D44,
RENDERBUFFER_RED_SIZE : 0x8D50,
RENDERBUFFER_GREEN_SIZE : 0x8D51,
RENDERBUFFER_BLUE_SIZE : 0x8D52,
RENDERBUFFER_ALPHA_SIZE : 0x8D53,
RENDERBUFFER_DEPTH_SIZE : 0x8D54,
RENDERBUFFER_STENCIL_SIZE : 0x8D55,
FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE : 0x8CD0,
FRAMEBUFFER_ATTACHMENT_OBJECT_NAME : 0x8CD1,
FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL : 0x8CD2,
FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE : 0x8CD3,
COLOR_ATTACHMENT0 : 0x8CE0,
DEPTH_ATTACHMENT : 0x8D00,
STENCIL_ATTACHMENT : 0x8D20,
DEPTH_STENCIL_ATTACHMENT : 0x821A,
NONE : 0,
FRAMEBUFFER_COMPLETE : 0x8CD5,
FRAMEBUFFER_INCOMPLETE_ATTACHMENT : 0x8CD6,
FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT : 0x8CD7,
FRAMEBUFFER_INCOMPLETE_DIMENSIONS : 0x8CD9,
FRAMEBUFFER_UNSUPPORTED : 0x8CDD,
FRAMEBUFFER_BINDING : 0x8CA6,
RENDERBUFFER_BINDING : 0x8CA7,
MAX_RENDERBUFFER_SIZE : 0x84E8,
INVALID_FRAMEBUFFER_OPERATION : 0x0506,
UNPACK_FLIP_Y_WEBGL : 0x9240,
UNPACK_PREMULTIPLY_ALPHA_WEBGL : 0x9241,
CONTEXT_LOST_WEBGL : 0x9242,
UNPACK_COLORSPACE_CONVERSION_WEBGL : 0x9243,
BROWSER_DEFAULT_WEBGL : 0x9244,
// WEBGL_compressed_texture_s3tc
COMPRESSED_RGB_S3TC_DXT1_EXT : 0x83F0,
COMPRESSED_RGBA_S3TC_DXT1_EXT : 0x83F1,
COMPRESSED_RGBA_S3TC_DXT3_EXT : 0x83F2,
COMPRESSED_RGBA_S3TC_DXT5_EXT : 0x83F3,
// WEBGL_compressed_texture_pvrtc
COMPRESSED_RGB_PVRTC_4BPPV1_IMG : 0x8C00,
COMPRESSED_RGB_PVRTC_2BPPV1_IMG : 0x8C01,
COMPRESSED_RGBA_PVRTC_4BPPV1_IMG : 0x8C02,
COMPRESSED_RGBA_PVRTC_2BPPV1_IMG : 0x8C03,
// WEBGL_compressed_texture_etc1
COMPRESSED_RGB_ETC1_WEBGL : 0x8D64,
// Desktop OpenGL
DOUBLE : 0x140A,
// WebGL 2
READ_BUFFER : 0x0C02,
UNPACK_ROW_LENGTH : 0x0CF2,
UNPACK_SKIP_ROWS : 0x0CF3,
UNPACK_SKIP_PIXELS : 0x0CF4,
PACK_ROW_LENGTH : 0x0D02,
PACK_SKIP_ROWS : 0x0D03,
PACK_SKIP_PIXELS : 0x0D04,
COLOR : 0x1800,
DEPTH : 0x1801,
STENCIL : 0x1802,
RED : 0x1903,
RGB8 : 0x8051,
RGBA8 : 0x8058,
RGB10_A2 : 0x8059,
TEXTURE_BINDING_3D : 0x806A,
UNPACK_SKIP_IMAGES : 0x806D,
UNPACK_IMAGE_HEIGHT : 0x806E,
TEXTURE_3D : 0x806F,
TEXTURE_WRAP_R : 0x8072,
MAX_3D_TEXTURE_SIZE : 0x8073,
UNSIGNED_INT_2_10_10_10_REV : 0x8368,
MAX_ELEMENTS_VERTICES : 0x80E8,
MAX_ELEMENTS_INDICES : 0x80E9,
TEXTURE_MIN_LOD : 0x813A,
TEXTURE_MAX_LOD : 0x813B,
TEXTURE_BASE_LEVEL : 0x813C,
TEXTURE_MAX_LEVEL : 0x813D,
MIN : 0x8007,
MAX : 0x8008,
DEPTH_COMPONENT24 : 0x81A6,
MAX_TEXTURE_LOD_BIAS : 0x84FD,
TEXTURE_COMPARE_MODE : 0x884C,
TEXTURE_COMPARE_FUNC : 0x884D,
CURRENT_QUERY : 0x8865,
QUERY_RESULT : 0x8866,
QUERY_RESULT_AVAILABLE : 0x8867,
STREAM_READ : 0x88E1,
STREAM_COPY : 0x88E2,
STATIC_READ : 0x88E5,
STATIC_COPY : 0x88E6,
DYNAMIC_READ : 0x88E9,
DYNAMIC_COPY : 0x88EA,
MAX_DRAW_BUFFERS : 0x8824,
DRAW_BUFFER0 : 0x8825,
DRAW_BUFFER1 : 0x8826,
DRAW_BUFFER2 : 0x8827,
DRAW_BUFFER3 : 0x8828,
DRAW_BUFFER4 : 0x8829,
DRAW_BUFFER5 : 0x882A,
DRAW_BUFFER6 : 0x882B,
DRAW_BUFFER7 : 0x882C,
DRAW_BUFFER8 : 0x882D,
DRAW_BUFFER9 : 0x882E,
DRAW_BUFFER10 : 0x882F,
DRAW_BUFFER11 : 0x8830,
DRAW_BUFFER12 : 0x8831,
DRAW_BUFFER13 : 0x8832,
DRAW_BUFFER14 : 0x8833,
DRAW_BUFFER15 : 0x8834,
MAX_FRAGMENT_UNIFORM_COMPONENTS : 0x8B49,
MAX_VERTEX_UNIFORM_COMPONENTS : 0x8B4A,
SAMPLER_3D : 0x8B5F,
SAMPLER_2D_SHADOW : 0x8B62,
FRAGMENT_SHADER_DERIVATIVE_HINT : 0x8B8B,
PIXEL_PACK_BUFFER : 0x88EB,
PIXEL_UNPACK_BUFFER : 0x88EC,
PIXEL_PACK_BUFFER_BINDING : 0x88ED,
PIXEL_UNPACK_BUFFER_BINDING : 0x88EF,
FLOAT_MAT2x3 : 0x8B65,
FLOAT_MAT2x4 : 0x8B66,
FLOAT_MAT3x2 : 0x8B67,
FLOAT_MAT3x4 : 0x8B68,
FLOAT_MAT4x2 : 0x8B69,
FLOAT_MAT4x3 : 0x8B6A,
SRGB : 0x8C40,
SRGB8 : 0x8C41,
SRGB8_ALPHA8 : 0x8C43,
COMPARE_REF_TO_TEXTURE : 0x884E,
RGBA32F : 0x8814,
RGB32F : 0x8815,
RGBA16F : 0x881A,
RGB16F : 0x881B,
VERTEX_ATTRIB_ARRAY_INTEGER : 0x88FD,
MAX_ARRAY_TEXTURE_LAYERS : 0x88FF,
MIN_PROGRAM_TEXEL_OFFSET : 0x8904,
MAX_PROGRAM_TEXEL_OFFSET : 0x8905,
MAX_VARYING_COMPONENTS : 0x8B4B,
TEXTURE_2D_ARRAY : 0x8C1A,
TEXTURE_BINDING_2D_ARRAY : 0x8C1D,
R11F_G11F_B10F : 0x8C3A,
UNSIGNED_INT_10F_11F_11F_REV : 0x8C3B,
RGB9_E5 : 0x8C3D,
UNSIGNED_INT_5_9_9_9_REV : 0x8C3E,
TRANSFORM_FEEDBACK_BUFFER_MODE : 0x8C7F,
MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS : 0x8C80,
TRANSFORM_FEEDBACK_VARYINGS : 0x8C83,
TRANSFORM_FEEDBACK_BUFFER_START : 0x8C84,
TRANSFORM_FEEDBACK_BUFFER_SIZE : 0x8C85,
TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN : 0x8C88,
RASTERIZER_DISCARD : 0x8C89,
MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS : 0x8C8A,
MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS : 0x8C8B,
INTERLEAVED_ATTRIBS : 0x8C8C,
SEPARATE_ATTRIBS : 0x8C8D,
TRANSFORM_FEEDBACK_BUFFER : 0x8C8E,
TRANSFORM_FEEDBACK_BUFFER_BINDING : 0x8C8F,
RGBA32UI : 0x8D70,
RGB32UI : 0x8D71,
RGBA16UI : 0x8D76,
RGB16UI : 0x8D77,
RGBA8UI : 0x8D7C,
RGB8UI : 0x8D7D,
RGBA32I : 0x8D82,
RGB32I : 0x8D83,
RGBA16I : 0x8D88,
RGB16I : 0x8D89,
RGBA8I : 0x8D8E,
RGB8I : 0x8D8F,
RED_INTEGER : 0x8D94,
RGB_INTEGER : 0x8D98,
RGBA_INTEGER : 0x8D99,
SAMPLER_2D_ARRAY : 0x8DC1,
SAMPLER_2D_ARRAY_SHADOW : 0x8DC4,
SAMPLER_CUBE_SHADOW : 0x8DC5,
UNSIGNED_INT_VEC2 : 0x8DC6,
UNSIGNED_INT_VEC3 : 0x8DC7,
UNSIGNED_INT_VEC4 : 0x8DC8,
INT_SAMPLER_2D : 0x8DCA,
INT_SAMPLER_3D : 0x8DCB,
INT_SAMPLER_CUBE : 0x8DCC,
INT_SAMPLER_2D_ARRAY : 0x8DCF,
UNSIGNED_INT_SAMPLER_2D : 0x8DD2,
UNSIGNED_INT_SAMPLER_3D : 0x8DD3,
UNSIGNED_INT_SAMPLER_CUBE : 0x8DD4,
UNSIGNED_INT_SAMPLER_2D_ARRAY : 0x8DD7,
DEPTH_COMPONENT32F : 0x8CAC,
DEPTH32F_STENCIL8 : 0x8CAD,
FLOAT_32_UNSIGNED_INT_24_8_REV : 0x8DAD,
FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING : 0x8210,
FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE : 0x8211,
FRAMEBUFFER_ATTACHMENT_RED_SIZE : 0x8212,
FRAMEBUFFER_ATTACHMENT_GREEN_SIZE : 0x8213,
FRAMEBUFFER_ATTACHMENT_BLUE_SIZE : 0x8214,
FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE : 0x8215,
FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE : 0x8216,
FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE : 0x8217,
FRAMEBUFFER_DEFAULT : 0x8218,
UNSIGNED_INT_24_8 : 0x84FA,
DEPTH24_STENCIL8 : 0x88F0,
UNSIGNED_NORMALIZED : 0x8C17,
DRAW_FRAMEBUFFER_BINDING : 0x8CA6, // Same as FRAMEBUFFER_BINDING
READ_FRAMEBUFFER : 0x8CA8,
DRAW_FRAMEBUFFER : 0x8CA9,
READ_FRAMEBUFFER_BINDING : 0x8CAA,
RENDERBUFFER_SAMPLES : 0x8CAB,
FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER : 0x8CD4,
MAX_COLOR_ATTACHMENTS : 0x8CDF,
COLOR_ATTACHMENT1 : 0x8CE1,
COLOR_ATTACHMENT2 : 0x8CE2,
COLOR_ATTACHMENT3 : 0x8CE3,
COLOR_ATTACHMENT4 : 0x8CE4,
COLOR_ATTACHMENT5 : 0x8CE5,
COLOR_ATTACHMENT6 : 0x8CE6,
COLOR_ATTACHMENT7 : 0x8CE7,
COLOR_ATTACHMENT8 : 0x8CE8,
COLOR_ATTACHMENT9 : 0x8CE9,
COLOR_ATTACHMENT10 : 0x8CEA,
COLOR_ATTACHMENT11 : 0x8CEB,
COLOR_ATTACHMENT12 : 0x8CEC,
COLOR_ATTACHMENT13 : 0x8CED,
COLOR_ATTACHMENT14 : 0x8CEE,
COLOR_ATTACHMENT15 : 0x8CEF,
FRAMEBUFFER_INCOMPLETE_MULTISAMPLE : 0x8D56,
MAX_SAMPLES : 0x8D57,
HALF_FLOAT : 0x140B,
RG : 0x8227,
RG_INTEGER : 0x8228,
R8 : 0x8229,
RG8 : 0x822B,
R16F : 0x822D,
R32F : 0x822E,
RG16F : 0x822F,
RG32F : 0x8230,
R8I : 0x8231,
R8UI : 0x8232,
R16I : 0x8233,
R16UI : 0x8234,
R32I : 0x8235,
R32UI : 0x8236,
RG8I : 0x8237,
RG8UI : 0x8238,
RG16I : 0x8239,
RG16UI : 0x823A,
RG32I : 0x823B,
RG32UI : 0x823C,
VERTEX_ARRAY_BINDING : 0x85B5,
R8_SNORM : 0x8F94,
RG8_SNORM : 0x8F95,
RGB8_SNORM : 0x8F96,
RGBA8_SNORM : 0x8F97,
SIGNED_NORMALIZED : 0x8F9C,
COPY_READ_BUFFER : 0x8F36,
COPY_WRITE_BUFFER : 0x8F37,
COPY_READ_BUFFER_BINDING : 0x8F36, // Same as COPY_READ_BUFFER
COPY_WRITE_BUFFER_BINDING : 0x8F37, // Same as COPY_WRITE_BUFFER
UNIFORM_BUFFER : 0x8A11,
UNIFORM_BUFFER_BINDING : 0x8A28,
UNIFORM_BUFFER_START : 0x8A29,
UNIFORM_BUFFER_SIZE : 0x8A2A,
MAX_VERTEX_UNIFORM_BLOCKS : 0x8A2B,
MAX_FRAGMENT_UNIFORM_BLOCKS : 0x8A2D,
MAX_COMBINED_UNIFORM_BLOCKS : 0x8A2E,
MAX_UNIFORM_BUFFER_BINDINGS : 0x8A2F,
MAX_UNIFORM_BLOCK_SIZE : 0x8A30,
MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS : 0x8A31,
MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS : 0x8A33,
UNIFORM_BUFFER_OFFSET_ALIGNMENT : 0x8A34,
ACTIVE_UNIFORM_BLOCKS : 0x8A36,
UNIFORM_TYPE : 0x8A37,
UNIFORM_SIZE : 0x8A38,
UNIFORM_BLOCK_INDEX : 0x8A3A,
UNIFORM_OFFSET : 0x8A3B,
UNIFORM_ARRAY_STRIDE : 0x8A3C,
UNIFORM_MATRIX_STRIDE : 0x8A3D,
UNIFORM_IS_ROW_MAJOR : 0x8A3E,
UNIFORM_BLOCK_BINDING : 0x8A3F,
UNIFORM_BLOCK_DATA_SIZE : 0x8A40,
UNIFORM_BLOCK_ACTIVE_UNIFORMS : 0x8A42,
UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES : 0x8A43,
UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER : 0x8A44,
UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER : 0x8A46,
INVALID_INDEX : 0xFFFFFFFF,
MAX_VERTEX_OUTPUT_COMPONENTS : 0x9122,
MAX_FRAGMENT_INPUT_COMPONENTS : 0x9125,
MAX_SERVER_WAIT_TIMEOUT : 0x9111,
OBJECT_TYPE : 0x9112,
SYNC_CONDITION : 0x9113,
SYNC_STATUS : 0x9114,
SYNC_FLAGS : 0x9115,
SYNC_FENCE : 0x9116,
SYNC_GPU_COMMANDS_COMPLETE : 0x9117,
UNSIGNALED : 0x9118,
SIGNALED : 0x9119,
ALREADY_SIGNALED : 0x911A,
TIMEOUT_EXPIRED : 0x911B,
CONDITION_SATISFIED : 0x911C,
WAIT_FAILED : 0x911D,
SYNC_FLUSH_COMMANDS_BIT : 0x00000001,
VERTEX_ATTRIB_ARRAY_DIVISOR : 0x88FE,
ANY_SAMPLES_PASSED : 0x8C2F,
ANY_SAMPLES_PASSED_CONSERVATIVE : 0x8D6A,
SAMPLER_BINDING : 0x8919,
RGB10_A2UI : 0x906F,
INT_2_10_10_10_REV : 0x8D9F,
TRANSFORM_FEEDBACK : 0x8E22,
TRANSFORM_FEEDBACK_PAUSED : 0x8E23,
TRANSFORM_FEEDBACK_ACTIVE : 0x8E24,
TRANSFORM_FEEDBACK_BINDING : 0x8E25,
COMPRESSED_R11_EAC : 0x9270,
COMPRESSED_SIGNED_R11_EAC : 0x9271,
COMPRESSED_RG11_EAC : 0x9272,
COMPRESSED_SIGNED_RG11_EAC : 0x9273,
COMPRESSED_RGB8_ETC2 : 0x9274,
COMPRESSED_SRGB8_ETC2 : 0x9275,
COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 : 0x9276,
COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 : 0x9277,
COMPRESSED_RGBA8_ETC2_EAC : 0x9278,
COMPRESSED_SRGB8_ALPHA8_ETC2_EAC : 0x9279,
TEXTURE_IMMUTABLE_FORMAT : 0x912F,
MAX_ELEMENT_INDEX : 0x8D6B,
TEXTURE_IMMUTABLE_LEVELS : 0x82DF,
// Extensions
MAX_TEXTURE_MAX_ANISOTROPY_EXT : 0x84FF
};
return freezeObject(WebGLConstants);
});
/*global define*/
define('Core/ComponentDatatype',[
'./defaultValue',
'./defined',
'./DeveloperError',
'./FeatureDetection',
'./freezeObject',
'./WebGLConstants'
], function(
defaultValue,
defined,
DeveloperError,
FeatureDetection,
freezeObject,
WebGLConstants) {
'use strict';
// Bail out if the browser doesn't support typed arrays, to prevent the setup function
// from failing, since we won't be able to create a WebGL context anyway.
if (!FeatureDetection.supportsTypedArrays()) {
return {};
}
/**
* WebGL component datatypes. Components are intrinsics,
* which form attributes, which form vertices.
*
* @exports ComponentDatatype
*/
var ComponentDatatype = {
/**
* 8-bit signed byte corresponding to <code>gl.BYTE</code> and the type
* of an element in <code>Int8Array</code>.
*
* @type {Number}
* @constant
*/
BYTE : WebGLConstants.BYTE,
/**
* 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
* of an element in <code>Uint8Array</code>.
*
* @type {Number}
* @constant
*/
UNSIGNED_BYTE : WebGLConstants.UNSIGNED_BYTE,
/**
* 16-bit signed short corresponding to <code>SHORT</code> and the type
* of an element in <code>Int16Array</code>.
*
* @type {Number}
* @constant
*/
SHORT : WebGLConstants.SHORT,
/**
* 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
* of an element in <code>Uint16Array</code>.
*
* @type {Number}
* @constant
*/
UNSIGNED_SHORT : WebGLConstants.UNSIGNED_SHORT,
/**
* 32-bit signed int corresponding to <code>INT</code> and the type
* of an element in <code>Int32Array</code>.
*
* @memberOf ComponentDatatype
*
* @type {Number}
* @constant
*/
INT : WebGLConstants.INT,
/**
* 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
* of an element in <code>Uint32Array</code>.
*
* @memberOf ComponentDatatype
*
* @type {Number}
* @constant
*/
UNSIGNED_INT : WebGLConstants.UNSIGNED_INT,
/**
* 32-bit floating-point corresponding to <code>FLOAT</code> and the type
* of an element in <code>Float32Array</code>.
*
* @type {Number}
* @constant
*/
FLOAT : WebGLConstants.FLOAT,
/**
* 64-bit floating-point corresponding to <code>gl.DOUBLE</code> (in Desktop OpenGL;
* this is not supported in WebGL, and is emulated in Cesium via {@link GeometryPipeline.encodeAttribute})
* and the type of an element in <code>Float64Array</code>.
*
* @memberOf ComponentDatatype
*
* @type {Number}
* @constant
* @default 0x140A
*/
DOUBLE : WebGLConstants.DOUBLE
};
/**
* Returns the size, in bytes, of the corresponding datatype.
*
* @param {ComponentDatatype} componentDatatype The component datatype to get the size of.
* @returns {Number} The size in bytes.
*
* @exception {DeveloperError} componentDatatype is not a valid value.
*
* @example
* // Returns Int8Array.BYTES_PER_ELEMENT
* var size = Cesium.ComponentDatatype.getSizeInBytes(Cesium.ComponentDatatype.BYTE);
*/
ComponentDatatype.getSizeInBytes = function(componentDatatype){
if (!defined(componentDatatype)) {
throw new DeveloperError('value is required.');
}
switch (componentDatatype) {
case ComponentDatatype.BYTE:
return Int8Array.BYTES_PER_ELEMENT;
case ComponentDatatype.UNSIGNED_BYTE:
return Uint8Array.BYTES_PER_ELEMENT;
case ComponentDatatype.SHORT:
return Int16Array.BYTES_PER_ELEMENT;
case ComponentDatatype.UNSIGNED_SHORT:
return Uint16Array.BYTES_PER_ELEMENT;
case ComponentDatatype.INT:
return Int32Array.BYTES_PER_ELEMENT;
case ComponentDatatype.UNSIGNED_INT:
return Uint32Array.BYTES_PER_ELEMENT;
case ComponentDatatype.FLOAT:
return Float32Array.BYTES_PER_ELEMENT;
case ComponentDatatype.DOUBLE:
return Float64Array.BYTES_PER_ELEMENT;
default:
throw new DeveloperError('componentDatatype is not a valid value.');
}
};
/**
* Gets the {@link ComponentDatatype} for the provided TypedArray instance.
*
* @param {TypedArray} array The typed array.
* @returns {ComponentDatatype} The ComponentDatatype for the provided array, or undefined if the array is not a TypedArray.
*/
ComponentDatatype.fromTypedArray = function(array) {
if (array instanceof Int8Array) {
return ComponentDatatype.BYTE;
}
if (array instanceof Uint8Array) {
return ComponentDatatype.UNSIGNED_BYTE;
}
if (array instanceof Int16Array) {
return ComponentDatatype.SHORT;
}
if (array instanceof Uint16Array) {
return ComponentDatatype.UNSIGNED_SHORT;
}
if (array instanceof Int32Array) {
return ComponentDatatype.INT;
}
if (array instanceof Uint32Array) {
return ComponentDatatype.UNSIGNED_INT;
}
if (array instanceof Float32Array) {
return ComponentDatatype.FLOAT;
}
if (array instanceof Float64Array) {
return ComponentDatatype.DOUBLE;
}
};
/**
* Validates that the provided component datatype is a valid {@link ComponentDatatype}
*
* @param {ComponentDatatype} componentDatatype The component datatype to validate.
* @returns {Boolean} <code>true</code> if the provided component datatype is a valid value; otherwise, <code>false</code>.
*
* @example
* if (!Cesium.ComponentDatatype.validate(componentDatatype)) {
* throw new Cesium.DeveloperError('componentDatatype must be a valid value.');
* }
*/
ComponentDatatype.validate = function(componentDatatype) {
return defined(componentDatatype) &&
(componentDatatype === ComponentDatatype.BYTE ||
componentDatatype === ComponentDatatype.UNSIGNED_BYTE ||
componentDatatype === ComponentDatatype.SHORT ||
componentDatatype === ComponentDatatype.UNSIGNED_SHORT ||
componentDatatype === ComponentDatatype.INT ||
componentDatatype === ComponentDatatype.UNSIGNED_INT ||
componentDatatype === ComponentDatatype.FLOAT ||
componentDatatype === ComponentDatatype.DOUBLE);
};
/**
* Creates a typed array corresponding to component data type.
*
* @param {ComponentDatatype} componentDatatype The component data type.
* @param {Number|Array} valuesOrLength The length of the array to create or an array.
* @returns {Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array} A typed array.
*
* @exception {DeveloperError} componentDatatype is not a valid value.
*
* @example
* // creates a Float32Array with length of 100
* var typedArray = Cesium.ComponentDatatype.createTypedArray(Cesium.ComponentDatatype.FLOAT, 100);
*/
ComponentDatatype.createTypedArray = function(componentDatatype, valuesOrLength) {
if (!defined(componentDatatype)) {
throw new DeveloperError('componentDatatype is required.');
}
if (!defined(valuesOrLength)) {
throw new DeveloperError('valuesOrLength is required.');
}
switch (componentDatatype) {
case ComponentDatatype.BYTE:
return new Int8Array(valuesOrLength);
case ComponentDatatype.UNSIGNED_BYTE:
return new Uint8Array(valuesOrLength);
case ComponentDatatype.SHORT:
return new Int16Array(valuesOrLength);
case ComponentDatatype.UNSIGNED_SHORT:
return new Uint16Array(valuesOrLength);
case ComponentDatatype.INT:
return new Int32Array(valuesOrLength);
case ComponentDatatype.UNSIGNED_INT:
return new Uint32Array(valuesOrLength);
case ComponentDatatype.FLOAT:
return new Float32Array(valuesOrLength);
case ComponentDatatype.DOUBLE:
return new Float64Array(valuesOrLength);
default:
throw new DeveloperError('componentDatatype is not a valid value.');
}
};
/**
* Creates a typed view of an array of bytes.
*
* @param {ComponentDatatype} componentDatatype The type of the view to create.
* @param {ArrayBuffer} buffer The buffer storage to use for the view.
* @param {Number} [byteOffset] The offset, in bytes, to the first element in the view.
* @param {Number} [length] The number of elements in the view.
* @returns {Int8Array|Uint8Array|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array} A typed array view of the buffer.
*
* @exception {DeveloperError} componentDatatype is not a valid value.
*/
ComponentDatatype.createArrayBufferView = function(componentDatatype, buffer, byteOffset, length) {
if (!defined(componentDatatype)) {
throw new DeveloperError('componentDatatype is required.');
}
if (!defined(buffer)) {
throw new DeveloperError('buffer is required.');
}
byteOffset = defaultValue(byteOffset, 0);
length = defaultValue(length, (buffer.byteLength - byteOffset) / ComponentDatatype.getSizeInBytes(componentDatatype));
switch (componentDatatype) {
case ComponentDatatype.BYTE:
return new Int8Array(buffer, byteOffset, length);
case ComponentDatatype.UNSIGNED_BYTE:
return new Uint8Array(buffer, byteOffset, length);
case ComponentDatatype.SHORT:
return new Int16Array(buffer, byteOffset, length);
case ComponentDatatype.UNSIGNED_SHORT:
return new Uint16Array(buffer, byteOffset, length);
case ComponentDatatype.INT:
return new Int32Array(buffer, byteOffset, length);
case ComponentDatatype.UNSIGNED_INT:
return new Uint32Array(buffer, byteOffset, length);
case ComponentDatatype.FLOAT:
return new Float32Array(buffer, byteOffset, length);
case ComponentDatatype.DOUBLE:
return new Float64Array(buffer, byteOffset, length);
default:
throw new DeveloperError('componentDatatype is not a valid value.');
}
};
/**
* Get the ComponentDatatype from its name.
*
* @param {String} name The name of the ComponentDatatype.
* @returns {ComponentDatatype} The ComponentDatatype.
*
* @exception {DeveloperError} name is not a valid value.
*/
ComponentDatatype.fromName = function(name) {
switch (name) {
case 'BYTE':
return ComponentDatatype.BYTE;
case 'UNSIGNED_BYTE':
return ComponentDatatype.UNSIGNED_BYTE;
case 'SHORT':
return ComponentDatatype.SHORT;
case 'UNSIGNED_SHORT':
return ComponentDatatype.UNSIGNED_SHORT;
case 'INT':
return ComponentDatatype.INT;
case 'UNSIGNED_INT':
return ComponentDatatype.UNSIGNED_INT;
case 'FLOAT':
return ComponentDatatype.FLOAT;
case 'DOUBLE':
return ComponentDatatype.DOUBLE;
default:
throw new DeveloperError('name is not a valid value.');
}
};
return freezeObject(ComponentDatatype);
});
/*global define*/
define('Core/GeometryType',[
'./freezeObject'
], function(
freezeObject) {
'use strict';
/**
* @private
*/
var GeometryType = {
NONE : 0,
TRIANGLES : 1,
LINES : 2,
POLYLINES : 3
};
return freezeObject(GeometryType);
});
/*global define*/
define('Core/PrimitiveType',[
'./freezeObject',
'./WebGLConstants'
], function(
freezeObject,
WebGLConstants) {
'use strict';
/**
* The type of a geometric primitive, i.e., points, lines, and triangles.
*
* @exports PrimitiveType
*/
var PrimitiveType = {
/**
* Points primitive where each vertex (or index) is a separate point.
*
* @type {Number}
* @constant
*/
POINTS : WebGLConstants.POINTS,
/**
* Lines primitive where each two vertices (or indices) is a line segment. Line segments are not necessarily connected.
*
* @type {Number}
* @constant
*/
LINES : WebGLConstants.LINES,
/**
* Line loop primitive where each vertex (or index) after the first connects a line to
* the previous vertex, and the last vertex implicitly connects to the first.
*
* @type {Number}
* @constant
*/
LINE_LOOP : WebGLConstants.LINE_LOOP,
/**
* Line strip primitive where each vertex (or index) after the first connects a line to the previous vertex.
*
* @type {Number}
* @constant
*/
LINE_STRIP : WebGLConstants.LINE_STRIP,
/**
* Triangles primitive where each three vertices (or indices) is a triangle. Triangles do not necessarily share edges.
*
* @type {Number}
* @constant
*/
TRIANGLES : WebGLConstants.TRIANGLES,
/**
* Triangle strip primitive where each vertex (or index) after the first two connect to
* the previous two vertices forming a triangle. For example, this can be used to model a wall.
*
* @type {Number}
* @constant
*/
TRIANGLE_STRIP : WebGLConstants.TRIANGLE_STRIP,
/**
* Triangle fan primitive where each vertex (or index) after the first two connect to
* the previous vertex and the first vertex forming a triangle. For example, this can be used
* to model a cone or circle.
*
* @type {Number}
* @constant
*/
TRIANGLE_FAN : WebGLConstants.TRIANGLE_FAN,
/**
* @private
*/
validate : function(primitiveType) {
return primitiveType === PrimitiveType.POINTS ||
primitiveType === PrimitiveType.LINES ||
primitiveType === PrimitiveType.LINE_LOOP ||
primitiveType === PrimitiveType.LINE_STRIP ||
primitiveType === PrimitiveType.TRIANGLES ||
primitiveType === PrimitiveType.TRIANGLE_STRIP ||
primitiveType === PrimitiveType.TRIANGLE_FAN;
}
};
return freezeObject(PrimitiveType);
});
/*global define*/
define('Core/Geometry',[
'./defaultValue',
'./defined',
'./DeveloperError',
'./GeometryType',
'./PrimitiveType'
], function(
defaultValue,
defined,
DeveloperError,
GeometryType,
PrimitiveType) {
'use strict';
/**
* A geometry representation with attributes forming vertices and optional index data
* defining primitives. Geometries and an {@link Appearance}, which describes the shading,
* can be assigned to a {@link Primitive} for visualization. A <code>Primitive</code> can
* be created from many heterogeneous - in many cases - geometries for performance.
* <p>
* Geometries can be transformed and optimized using functions in {@link GeometryPipeline}.
* </p>
*
* @alias Geometry
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {GeometryAttributes} options.attributes Attributes, which make up the geometry's vertices.
* @param {PrimitiveType} [options.primitiveType=PrimitiveType.TRIANGLES] The type of primitives in the geometry.
* @param {Uint16Array|Uint32Array} [options.indices] Optional index data that determines the primitives in the geometry.
* @param {BoundingSphere} [options.boundingSphere] An optional bounding sphere that fully enclosed the geometry.
*
* @see PolygonGeometry
* @see RectangleGeometry
* @see EllipseGeometry
* @see CircleGeometry
* @see WallGeometry
* @see SimplePolylineGeometry
* @see BoxGeometry
* @see EllipsoidGeometry
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Geometry%20and%20Appearances.html|Geometry and Appearances Demo}
*
* @example
* // Create geometry with a position attribute and indexed lines.
* var positions = new Float64Array([
* 0.0, 0.0, 0.0,
* 7500000.0, 0.0, 0.0,
* 0.0, 7500000.0, 0.0
* ]);
*
* var geometry = new Cesium.Geometry({
* attributes : {
* position : new Cesium.GeometryAttribute({
* componentDatatype : Cesium.ComponentDatatype.DOUBLE,
* componentsPerAttribute : 3,
* values : positions
* })
* },
* indices : new Uint16Array([0, 1, 1, 2, 2, 0]),
* primitiveType : Cesium.PrimitiveType.LINES,
* boundingSphere : Cesium.BoundingSphere.fromVertices(positions)
* });
*/
function Geometry(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(options.attributes)) {
throw new DeveloperError('options.attributes is required.');
}
/**
* Attributes, which make up the geometry's vertices. Each property in this object corresponds to a
* {@link GeometryAttribute} containing the attribute's data.
* <p>
* Attributes are always stored non-interleaved in a Geometry.
* </p>
* <p>
* There are reserved attribute names with well-known semantics. The following attributes
* are created by a Geometry (depending on the provided {@link VertexFormat}.
* <ul>
* <li><code>position</code> - 3D vertex position. 64-bit floating-point (for precision). 3 components per attribute. See {@link VertexFormat#position}.</li>
* <li><code>normal</code> - Normal (normalized), commonly used for lighting. 32-bit floating-point. 3 components per attribute. See {@link VertexFormat#normal}.</li>
* <li><code>st</code> - 2D texture coordinate. 32-bit floating-point. 2 components per attribute. See {@link VertexFormat#st}.</li>
* <li><code>bitangent</code> - Bitangent (normalized), used for tangent-space effects like bump mapping. 32-bit floating-point. 3 components per attribute. See {@link VertexFormat#bitangent}.</li>
* <li><code>tangent</code> - Tangent (normalized), used for tangent-space effects like bump mapping. 32-bit floating-point. 3 components per attribute. See {@link VertexFormat#tangent}.</li>
* </ul>
* </p>
* <p>
* The following attribute names are generally not created by a Geometry, but are added
* to a Geometry by a {@link Primitive} or {@link GeometryPipeline} functions to prepare
* the geometry for rendering.
* <ul>
* <li><code>position3DHigh</code> - High 32 bits for encoded 64-bit position computed with {@link GeometryPipeline.encodeAttribute}. 32-bit floating-point. 4 components per attribute.</li>
* <li><code>position3DLow</code> - Low 32 bits for encoded 64-bit position computed with {@link GeometryPipeline.encodeAttribute}. 32-bit floating-point. 4 components per attribute.</li>
* <li><code>position3DHigh</code> - High 32 bits for encoded 64-bit 2D (Columbus view) position computed with {@link GeometryPipeline.encodeAttribute}. 32-bit floating-point. 4 components per attribute.</li>
* <li><code>position2DLow</code> - Low 32 bits for encoded 64-bit 2D (Columbus view) position computed with {@link GeometryPipeline.encodeAttribute}. 32-bit floating-point. 4 components per attribute.</li>
* <li><code>color</code> - RGBA color (normalized) usually from {@link GeometryInstance#color}. 32-bit floating-point. 4 components per attribute.</li>
* <li><code>pickColor</code> - RGBA color used for picking. 32-bit floating-point. 4 components per attribute.</li>
* </ul>
* </p>
*
* @type GeometryAttributes
*
* @default undefined
*
*
* @example
* geometry.attributes.position = new Cesium.GeometryAttribute({
* componentDatatype : Cesium.ComponentDatatype.FLOAT,
* componentsPerAttribute : 3,
* values : new Float32Array(0)
* });
*
* @see GeometryAttribute
* @see VertexFormat
*/
this.attributes = options.attributes;
/**
* Optional index data that - along with {@link Geometry#primitiveType} -
* determines the primitives in the geometry.
*
* @type Array
*
* @default undefined
*/
this.indices = options.indices;
/**
* The type of primitives in the geometry. This is most often {@link PrimitiveType.TRIANGLES},
* but can varying based on the specific geometry.
*
* @type PrimitiveType
*
* @default undefined
*/
this.primitiveType = defaultValue(options.primitiveType, PrimitiveType.TRIANGLES);
/**
* An optional bounding sphere that fully encloses the geometry. This is
* commonly used for culling.
*
* @type BoundingSphere
*
* @default undefined
*/
this.boundingSphere = options.boundingSphere;
/**
* @private
*/
this.geometryType = defaultValue(options.geometryType, GeometryType.NONE);
/**
* @private
*/
this.boundingSphereCV = options.boundingSphereCV;
}
/**
* Computes the number of vertices in a geometry. The runtime is linear with
* respect to the number of attributes in a vertex, not the number of vertices.
*
* @param {Geometry} geometry The geometry.
* @returns {Number} The number of vertices in the geometry.
*
* @example
* var numVertices = Cesium.Geometry.computeNumberOfVertices(geometry);
*/
Geometry.computeNumberOfVertices = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
var numberOfVertices = -1;
for ( var property in geometry.attributes) {
if (geometry.attributes.hasOwnProperty(property) &&
defined(geometry.attributes[property]) &&
defined(geometry.attributes[property].values)) {
var attribute = geometry.attributes[property];
var num = attribute.values.length / attribute.componentsPerAttribute;
if ((numberOfVertices !== num) && (numberOfVertices !== -1)) {
throw new DeveloperError('All attribute lists must have the same number of attributes.');
}
numberOfVertices = num;
}
}
return numberOfVertices;
};
return Geometry;
});
/*global define*/
define('Core/GeometryAttribute',[
'./defaultValue',
'./defined',
'./DeveloperError'
], function(
defaultValue,
defined,
DeveloperError) {
'use strict';
/**
* Values and type information for geometry attributes. A {@link Geometry}
* generally contains one or more attributes. All attributes together form
* the geometry's vertices.
*
* @alias GeometryAttribute
* @constructor
*
* @param {Object} [options] Object with the following properties:
* @param {ComponentDatatype} [options.componentDatatype] The datatype of each component in the attribute, e.g., individual elements in values.
* @param {Number} [options.componentsPerAttribute] A number between 1 and 4 that defines the number of components in an attributes.
* @param {Boolean} [options.normalize=false] When <code>true</code> and <code>componentDatatype</code> is an integer format, indicate that the components should be mapped to the range [0, 1] (unsigned) or [-1, 1] (signed) when they are accessed as floating-point for rendering.
* @param {TypedArray} [options.values] The values for the attributes stored in a typed array.
*
* @exception {DeveloperError} options.componentsPerAttribute must be between 1 and 4.
*
*
* @example
* var geometry = new Cesium.Geometry({
* attributes : {
* position : new Cesium.GeometryAttribute({
* componentDatatype : Cesium.ComponentDatatype.FLOAT,
* componentsPerAttribute : 3,
* values : new Float32Array([
* 0.0, 0.0, 0.0,
* 7500000.0, 0.0, 0.0,
* 0.0, 7500000.0, 0.0
* ])
* })
* },
* primitiveType : Cesium.PrimitiveType.LINE_LOOP
* });
*
* @see Geometry
*/
function GeometryAttribute(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
if (!defined(options.componentDatatype)) {
throw new DeveloperError('options.componentDatatype is required.');
}
if (!defined(options.componentsPerAttribute)) {
throw new DeveloperError('options.componentsPerAttribute is required.');
}
if (options.componentsPerAttribute < 1 || options.componentsPerAttribute > 4) {
throw new DeveloperError('options.componentsPerAttribute must be between 1 and 4.');
}
if (!defined(options.values)) {
throw new DeveloperError('options.values is required.');
}
/**
* The datatype of each component in the attribute, e.g., individual elements in
* {@link GeometryAttribute#values}.
*
* @type ComponentDatatype
*
* @default undefined
*/
this.componentDatatype = options.componentDatatype;
/**
* A number between 1 and 4 that defines the number of components in an attributes.
* For example, a position attribute with x, y, and z components would have 3 as
* shown in the code example.
*
* @type Number
*
* @default undefined
*
* @example
* attribute.componentDatatype = Cesium.ComponentDatatype.FLOAT;
* attribute.componentsPerAttribute = 3;
* attribute.values = new Float32Array([
* 0.0, 0.0, 0.0,
* 7500000.0, 0.0, 0.0,
* 0.0, 7500000.0, 0.0
* ]);
*/
this.componentsPerAttribute = options.componentsPerAttribute;
/**
* When <code>true</code> and <code>componentDatatype</code> is an integer format,
* indicate that the components should be mapped to the range [0, 1] (unsigned)
* or [-1, 1] (signed) when they are accessed as floating-point for rendering.
* <p>
* This is commonly used when storing colors using {@link ComponentDatatype.UNSIGNED_BYTE}.
* </p>
*
* @type Boolean
*
* @default false
*
* @example
* attribute.componentDatatype = Cesium.ComponentDatatype.UNSIGNED_BYTE;
* attribute.componentsPerAttribute = 4;
* attribute.normalize = true;
* attribute.values = new Uint8Array([
* Cesium.Color.floatToByte(color.red),
* Cesium.Color.floatToByte(color.green),
* Cesium.Color.floatToByte(color.blue),
* Cesium.Color.floatToByte(color.alpha)
* ]);
*/
this.normalize = defaultValue(options.normalize, false);
/**
* The values for the attributes stored in a typed array. In the code example,
* every three elements in <code>values</code> defines one attributes since
* <code>componentsPerAttribute</code> is 3.
*
* @type TypedArray
*
* @default undefined
*
* @example
* attribute.componentDatatype = Cesium.ComponentDatatype.FLOAT;
* attribute.componentsPerAttribute = 3;
* attribute.values = new Float32Array([
* 0.0, 0.0, 0.0,
* 7500000.0, 0.0, 0.0,
* 0.0, 7500000.0, 0.0
* ]);
*/
this.values = options.values;
}
return GeometryAttribute;
});
/*global define*/
define('Core/GeometryAttributes',[
'./defaultValue'
], function(
defaultValue) {
'use strict';
/**
* Attributes, which make up a geometry's vertices. Each property in this object corresponds to a
* {@link GeometryAttribute} containing the attribute's data.
* <p>
* Attributes are always stored non-interleaved in a Geometry.
* </p>
*
* @alias GeometryAttributes
* @constructor
*/
function GeometryAttributes(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
/**
* The 3D position attribute.
* <p>
* 64-bit floating-point (for precision). 3 components per attribute.
* </p>
*
* @type GeometryAttribute
*
* @default undefined
*/
this.position = options.position;
/**
* The normal attribute (normalized), which is commonly used for lighting.
* <p>
* 32-bit floating-point. 3 components per attribute.
* </p>
*
* @type GeometryAttribute
*
* @default undefined
*/
this.normal = options.normal;
/**
* The 2D texture coordinate attribute.
* <p>
* 32-bit floating-point. 2 components per attribute
* </p>
*
* @type GeometryAttribute
*
* @default undefined
*/
this.st = options.st;
/**
* The bitangent attribute (normalized), which is used for tangent-space effects like bump mapping.
* <p>
* 32-bit floating-point. 3 components per attribute.
* </p>
*
* @type GeometryAttribute
*
* @default undefined
*/
this.bitangent = options.bitangent;
/**
* The tangent attribute (normalized), which is used for tangent-space effects like bump mapping.
* <p>
* 32-bit floating-point. 3 components per attribute.
* </p>
*
* @type GeometryAttribute
*
* @default undefined
*/
this.tangent = options.tangent;
/**
* The color attribute.
* <p>
* 8-bit unsigned integer. 4 components per attribute.
* </p>
*
* @type GeometryAttribute
*
* @default undefined
*/
this.color = options.color;
}
return GeometryAttributes;
});
/*global define*/
define('Core/IndexDatatype',[
'./defined',
'./DeveloperError',
'./freezeObject',
'./Math',
'./WebGLConstants'
], function(
defined,
DeveloperError,
freezeObject,
CesiumMath,
WebGLConstants) {
'use strict';
/**
* Constants for WebGL index datatypes. These corresponds to the
* <code>type</code> parameter of {@link http://www.khronos.org/opengles/sdk/docs/man/xhtml/glDrawElements.xml|drawElements}.
*
* @exports IndexDatatype
*/
var IndexDatatype = {
/**
* 8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
* of an element in <code>Uint8Array</code>.
*
* @type {Number}
* @constant
*/
UNSIGNED_BYTE : WebGLConstants.UNSIGNED_BYTE,
/**
* 16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
* of an element in <code>Uint16Array</code>.
*
* @type {Number}
* @constant
*/
UNSIGNED_SHORT : WebGLConstants.UNSIGNED_SHORT,
/**
* 32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
* of an element in <code>Uint32Array</code>.
*
* @type {Number}
* @constant
*/
UNSIGNED_INT : WebGLConstants.UNSIGNED_INT
};
/**
* Returns the size, in bytes, of the corresponding datatype.
*
* @param {IndexDatatype} indexDatatype The index datatype to get the size of.
* @returns {Number} The size in bytes.
*
* @example
* // Returns 2
* var size = Cesium.IndexDatatype.getSizeInBytes(Cesium.IndexDatatype.UNSIGNED_SHORT);
*/
IndexDatatype.getSizeInBytes = function(indexDatatype) {
switch(indexDatatype) {
case IndexDatatype.UNSIGNED_BYTE:
return Uint8Array.BYTES_PER_ELEMENT;
case IndexDatatype.UNSIGNED_SHORT:
return Uint16Array.BYTES_PER_ELEMENT;
case IndexDatatype.UNSIGNED_INT:
return Uint32Array.BYTES_PER_ELEMENT;
}
throw new DeveloperError('indexDatatype is required and must be a valid IndexDatatype constant.');
};
/**
* Validates that the provided index datatype is a valid {@link IndexDatatype}.
*
* @param {IndexDatatype} indexDatatype The index datatype to validate.
* @returns {Boolean} <code>true</code> if the provided index datatype is a valid value; otherwise, <code>false</code>.
*
* @example
* if (!Cesium.IndexDatatype.validate(indexDatatype)) {
* throw new Cesium.DeveloperError('indexDatatype must be a valid value.');
* }
*/
IndexDatatype.validate = function(indexDatatype) {
return defined(indexDatatype) &&
(indexDatatype === IndexDatatype.UNSIGNED_BYTE ||
indexDatatype === IndexDatatype.UNSIGNED_SHORT ||
indexDatatype === IndexDatatype.UNSIGNED_INT);
};
/**
* Creates a typed array that will store indices, using either <code><Uint16Array</code>
* or <code>Uint32Array</code> depending on the number of vertices.
*
* @param {Number} numberOfVertices Number of vertices that the indices will reference.
* @param {*} indicesLengthOrArray Passed through to the typed array constructor.
* @returns {Uint16Array|Uint32Array} A <code>Uint16Array</code> or <code>Uint32Array</code> constructed with <code>indicesLengthOrArray</code>.
*
* @example
* this.indices = Cesium.IndexDatatype.createTypedArray(positions.length / 3, numberOfIndices);
*/
IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
if (!defined(numberOfVertices)) {
throw new DeveloperError('numberOfVertices is required.');
}
if (numberOfVertices >= CesiumMath.SIXTY_FOUR_KILOBYTES) {
return new Uint32Array(indicesLengthOrArray);
}
return new Uint16Array(indicesLengthOrArray);
};
/**
* Creates a typed array from a source array buffer. The resulting typed array will store indices, using either <code><Uint16Array</code>
* or <code>Uint32Array</code> depending on the number of vertices.
*
* @param {Number} numberOfVertices Number of vertices that the indices will reference.
* @param {ArrayBuffer} sourceArray Passed through to the typed array constructor.
* @param {Number} byteOffset Passed through to the typed array constructor.
* @param {Number} length Passed through to the typed array constructor.
* @returns {Uint16Array|Uint32Array} A <code>Uint16Array</code> or <code>Uint32Array</code> constructed with <code>sourceArray</code>, <code>byteOffset</code>, and <code>length</code>.
*
*/
IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length) {
if (!defined(numberOfVertices)) {
throw new DeveloperError('numberOfVertices is required.');
}
if (!defined(sourceArray)) {
throw new DeveloperError('sourceArray is required.');
}
if (!defined(byteOffset)) {
throw new DeveloperError('byteOffset is required.');
}
if (numberOfVertices >= CesiumMath.SIXTY_FOUR_KILOBYTES) {
return new Uint32Array(sourceArray, byteOffset, length);
}
return new Uint16Array(sourceArray, byteOffset, length);
};
return freezeObject(IndexDatatype);
});
/*global define*/
define('Core/EllipsoidGeodesic',[
'./Cartesian3',
'./Cartographic',
'./defaultValue',
'./defined',
'./defineProperties',
'./DeveloperError',
'./Ellipsoid',
'./Math'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
defineProperties,
DeveloperError,
Ellipsoid,
CesiumMath) {
'use strict';
function setConstants(ellipsoidGeodesic) {
var uSquared = ellipsoidGeodesic._uSquared;
var a = ellipsoidGeodesic._ellipsoid.maximumRadius;
var b = ellipsoidGeodesic._ellipsoid.minimumRadius;
var f = (a - b) / a;
var cosineHeading = Math.cos(ellipsoidGeodesic._startHeading);
var sineHeading = Math.sin(ellipsoidGeodesic._startHeading);
var tanU = (1 - f) * Math.tan(ellipsoidGeodesic._start.latitude);
var cosineU = 1.0 / Math.sqrt(1.0 + tanU * tanU);
var sineU = cosineU * tanU;
var sigma = Math.atan2(tanU, cosineHeading);
var sineAlpha = cosineU * sineHeading;
var sineSquaredAlpha = sineAlpha * sineAlpha;
var cosineSquaredAlpha = 1.0 - sineSquaredAlpha;
var cosineAlpha = Math.sqrt(cosineSquaredAlpha);
var u2Over4 = uSquared / 4.0;
var u4Over16 = u2Over4 * u2Over4;
var u6Over64 = u4Over16 * u2Over4;
var u8Over256 = u4Over16 * u4Over16;
var a0 = (1.0 + u2Over4 - 3.0 * u4Over16 / 4.0 + 5.0 * u6Over64 / 4.0 - 175.0 * u8Over256 / 64.0);
var a1 = (1.0 - u2Over4 + 15.0 * u4Over16 / 8.0 - 35.0 * u6Over64 / 8.0);
var a2 = (1.0 - 3.0 * u2Over4 + 35.0 * u4Over16 / 4.0);
var a3 = (1.0 - 5.0 * u2Over4);
var distanceRatio = a0 * sigma - a1 * Math.sin(2.0 * sigma) * u2Over4 / 2.0 - a2 * Math.sin(4.0 * sigma) * u4Over16 / 16.0 -
a3 * Math.sin(6.0 * sigma) * u6Over64 / 48.0 - Math.sin(8.0 * sigma) * 5.0 * u8Over256 / 512;
var constants = ellipsoidGeodesic._constants;
constants.a = a;
constants.b = b;
constants.f = f;
constants.cosineHeading = cosineHeading;
constants.sineHeading = sineHeading;
constants.tanU = tanU;
constants.cosineU = cosineU;
constants.sineU = sineU;
constants.sigma = sigma;
constants.sineAlpha = sineAlpha;
constants.sineSquaredAlpha = sineSquaredAlpha;
constants.cosineSquaredAlpha = cosineSquaredAlpha;
constants.cosineAlpha = cosineAlpha;
constants.u2Over4 = u2Over4;
constants.u4Over16 = u4Over16;
constants.u6Over64 = u6Over64;
constants.u8Over256 = u8Over256;
constants.a0 = a0;
constants.a1 = a1;
constants.a2 = a2;
constants.a3 = a3;
constants.distanceRatio = distanceRatio;
}
function computeC(f, cosineSquaredAlpha) {
return f * cosineSquaredAlpha * (4.0 + f * (4.0 - 3.0 * cosineSquaredAlpha)) / 16.0;
}
function computeDeltaLambda(f, sineAlpha, cosineSquaredAlpha, sigma, sineSigma, cosineSigma, cosineTwiceSigmaMidpoint) {
var C = computeC(f, cosineSquaredAlpha);
return (1.0 - C) * f * sineAlpha * (sigma + C * sineSigma * (cosineTwiceSigmaMidpoint +
C * cosineSigma * (2.0 * cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint - 1.0)));
}
function vincentyInverseFormula(ellipsoidGeodesic, major, minor, firstLongitude, firstLatitude, secondLongitude, secondLatitude) {
var eff = (major - minor) / major;
var l = secondLongitude - firstLongitude;
var u1 = Math.atan((1 - eff) * Math.tan(firstLatitude));
var u2 = Math.atan((1 - eff) * Math.tan(secondLatitude));
var cosineU1 = Math.cos(u1);
var sineU1 = Math.sin(u1);
var cosineU2 = Math.cos(u2);
var sineU2 = Math.sin(u2);
var cc = cosineU1 * cosineU2;
var cs = cosineU1 * sineU2;
var ss = sineU1 * sineU2;
var sc = sineU1 * cosineU2;
var lambda = l;
var lambdaDot = CesiumMath.TWO_PI;
var cosineLambda = Math.cos(lambda);
var sineLambda = Math.sin(lambda);
var sigma;
var cosineSigma;
var sineSigma;
var cosineSquaredAlpha;
var cosineTwiceSigmaMidpoint;
do {
cosineLambda = Math.cos(lambda);
sineLambda = Math.sin(lambda);
var temp = cs - sc * cosineLambda;
sineSigma = Math.sqrt(cosineU2 * cosineU2 * sineLambda * sineLambda + temp * temp);
cosineSigma = ss + cc * cosineLambda;
sigma = Math.atan2(sineSigma, cosineSigma);
var sineAlpha;
if (sineSigma === 0.0) {
sineAlpha = 0.0;
cosineSquaredAlpha = 1.0;
} else {
sineAlpha = cc * sineLambda / sineSigma;
cosineSquaredAlpha = 1.0 - sineAlpha * sineAlpha;
}
lambdaDot = lambda;
cosineTwiceSigmaMidpoint = cosineSigma - 2.0 * ss / cosineSquaredAlpha;
if (isNaN(cosineTwiceSigmaMidpoint)) {
cosineTwiceSigmaMidpoint = 0.0;
}
lambda = l + computeDeltaLambda(eff, sineAlpha, cosineSquaredAlpha,
sigma, sineSigma, cosineSigma, cosineTwiceSigmaMidpoint);
} while (Math.abs(lambda - lambdaDot) > CesiumMath.EPSILON12);
var uSquared = cosineSquaredAlpha * (major * major - minor * minor) / (minor * minor);
var A = 1.0 + uSquared * (4096.0 + uSquared * (uSquared * (320.0 - 175.0 * uSquared) - 768.0)) / 16384.0;
var B = uSquared * (256.0 + uSquared * (uSquared * (74.0 - 47.0 * uSquared) - 128.0)) / 1024.0;
var cosineSquaredTwiceSigmaMidpoint = cosineTwiceSigmaMidpoint * cosineTwiceSigmaMidpoint;
var deltaSigma = B * sineSigma * (cosineTwiceSigmaMidpoint + B * (cosineSigma *
(2.0 * cosineSquaredTwiceSigmaMidpoint - 1.0) - B * cosineTwiceSigmaMidpoint *
(4.0 * sineSigma * sineSigma - 3.0) * (4.0 * cosineSquaredTwiceSigmaMidpoint - 3.0) / 6.0) / 4.0);
var distance = minor * A * (sigma - deltaSigma);
var startHeading = Math.atan2(cosineU2 * sineLambda, cs - sc * cosineLambda);
var endHeading = Math.atan2(cosineU1 * sineLambda, cs * cosineLambda - sc);
ellipsoidGeodesic._distance = distance;
ellipsoidGeodesic._startHeading = startHeading;
ellipsoidGeodesic._endHeading = endHeading;
ellipsoidGeodesic._uSquared = uSquared;
}
function computeProperties(ellipsoidGeodesic, start, end, ellipsoid) {
var firstCartesian = Cartesian3.normalize(ellipsoid.cartographicToCartesian(start, scratchCart2), scratchCart1);
var lastCartesian = Cartesian3.normalize(ellipsoid.cartographicToCartesian(end, scratchCart2), scratchCart2);
if (Math.abs(Math.abs(Cartesian3.angleBetween(firstCartesian, lastCartesian)) - Math.PI) < 0.0125) {
throw new DeveloperError('geodesic position is not unique');
}
vincentyInverseFormula(ellipsoidGeodesic, ellipsoid.maximumRadius, ellipsoid.minimumRadius,
start.longitude, start.latitude, end.longitude, end.latitude);
ellipsoidGeodesic._start = Cartographic.clone(start, ellipsoidGeodesic._start);
ellipsoidGeodesic._end = Cartographic.clone(end, ellipsoidGeodesic._end);
ellipsoidGeodesic._start.height = 0;
ellipsoidGeodesic._end.height = 0;
setConstants(ellipsoidGeodesic);
}
var scratchCart1 = new Cartesian3();
var scratchCart2 = new Cartesian3();
/**
* Initializes a geodesic on the ellipsoid connecting the two provided planetodetic points.
*
* @alias EllipsoidGeodesic
* @constructor
*
* @param {Cartographic} [start] The initial planetodetic point on the path.
* @param {Cartographic} [end] The final planetodetic point on the path.
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the geodesic lies.
*/
function EllipsoidGeodesic(start, end, ellipsoid) {
var e = defaultValue(ellipsoid, Ellipsoid.WGS84);
this._ellipsoid = e;
this._start = new Cartographic();
this._end = new Cartographic();
this._constants = {};
this._startHeading = undefined;
this._endHeading = undefined;
this._distance = undefined;
this._uSquared = undefined;
if (defined(start) && defined(end)) {
computeProperties(this, start, end, e);
}
}
defineProperties(EllipsoidGeodesic.prototype, {
/**
* Gets the ellipsoid.
* @memberof EllipsoidGeodesic.prototype
* @type {Ellipsoid}
* @readonly
*/
ellipsoid : {
get : function() {
return this._ellipsoid;
}
},
/**
* Gets the surface distance between the start and end point
* @memberof EllipsoidGeodesic.prototype
* @type {Number}
* @readonly
*/
surfaceDistance : {
get : function() {
if (!defined(this._distance)) {
throw new DeveloperError('set end positions before getting surfaceDistance');
}
return this._distance;
}
},
/**
* Gets the initial planetodetic point on the path.
* @memberof EllipsoidGeodesic.prototype
* @type {Cartographic}
* @readonly
*/
start : {
get : function() {
return this._start;
}
},
/**
* Gets the final planetodetic point on the path.
* @memberof EllipsoidGeodesic.prototype
* @type {Cartographic}
* @readonly
*/
end : {
get : function() {
return this._end;
}
},
/**
* Gets the heading at the initial point.
* @memberof EllipsoidGeodesic.prototype
* @type {Number}
* @readonly
*/
startHeading : {
get : function() {
if (!defined(this._distance)) {
throw new DeveloperError('set end positions before getting startHeading');
}
return this._startHeading;
}
},
/**
* Gets the heading at the final point.
* @memberof EllipsoidGeodesic.prototype
* @type {Number}
* @readonly
*/
endHeading : {
get : function() {
if (!defined(this._distance)) {
throw new DeveloperError('set end positions before getting endHeading');
}
return this._endHeading;
}
}
});
/**
* Sets the start and end points of the geodesic
*
* @param {Cartographic} start The initial planetodetic point on the path.
* @param {Cartographic} end The final planetodetic point on the path.
*/
EllipsoidGeodesic.prototype.setEndPoints = function(start, end) {
if (!defined(start)) {
throw new DeveloperError('start cartographic position is required');
}
if (!defined(end)) {
throw new DeveloperError('end cartgraphic position is required');
}
computeProperties(this, start, end, this._ellipsoid);
};
/**
* Provides the location of a point at the indicated portion along the geodesic.
*
* @param {Number} fraction The portion of the distance between the initial and final points.
* @param {Cartographic} result The object in which to store the result.
* @returns {Cartographic} The location of the point along the geodesic.
*/
EllipsoidGeodesic.prototype.interpolateUsingFraction = function(fraction, result) {
return this.interpolateUsingSurfaceDistance(this._distance * fraction, result);
};
/**
* Provides the location of a point at the indicated distance along the geodesic.
*
* @param {Number} distance The distance from the inital point to the point of interest along the geodesic
* @param {Cartographic} result The object in which to store the result.
* @returns {Cartographic} The location of the point along the geodesic.
*
* @exception {DeveloperError} start and end must be set before calling function interpolateUsingSurfaceDistance
*/
EllipsoidGeodesic.prototype.interpolateUsingSurfaceDistance = function(distance, result) {
if (!defined(this._distance)) {
throw new DeveloperError('start and end must be set before calling function interpolateUsingSurfaceDistance');
}
var constants = this._constants;
var s = constants.distanceRatio + distance / constants.b;
var cosine2S = Math.cos(2.0 * s);
var cosine4S = Math.cos(4.0 * s);
var cosine6S = Math.cos(6.0 * s);
var sine2S = Math.sin(2.0 * s);
var sine4S = Math.sin(4.0 * s);
var sine6S = Math.sin(6.0 * s);
var sine8S = Math.sin(8.0 * s);
var s2 = s * s;
var s3 = s * s2;
var u8Over256 = constants.u8Over256;
var u2Over4 = constants.u2Over4;
var u6Over64 = constants.u6Over64;
var u4Over16 = constants.u4Over16;
var sigma = 2.0 * s3 * u8Over256 * cosine2S / 3.0 +
s * (1.0 - u2Over4 + 7.0 * u4Over16 / 4.0 - 15.0 * u6Over64 / 4.0 + 579.0 * u8Over256 / 64.0 -
(u4Over16 - 15.0 * u6Over64 / 4.0 + 187.0 * u8Over256 / 16.0) * cosine2S -
(5.0 * u6Over64 / 4.0 - 115.0 * u8Over256 / 16.0) * cosine4S -
29.0 * u8Over256 * cosine6S / 16.0) +
(u2Over4 / 2.0 - u4Over16 + 71.0 * u6Over64 / 32.0 - 85.0 * u8Over256 / 16.0) * sine2S +
(5.0 * u4Over16 / 16.0 - 5.0 * u6Over64 / 4.0 + 383.0 * u8Over256 / 96.0) * sine4S -
s2 * ((u6Over64 - 11.0 * u8Over256 / 2.0) * sine2S + 5.0 * u8Over256 * sine4S / 2.0) +
(29.0 * u6Over64 / 96.0 - 29.0 * u8Over256 / 16.0) * sine6S +
539.0 * u8Over256 * sine8S / 1536.0;
var theta = Math.asin(Math.sin(sigma) * constants.cosineAlpha);
var latitude = Math.atan(constants.a / constants.b * Math.tan(theta));
// Redefine in terms of relative argument of latitude.
sigma = sigma - constants.sigma;
var cosineTwiceSigmaMidpoint = Math.cos(2.0 * constants.sigma + sigma);
var sineSigma = Math.sin(sigma);
var cosineSigma = Math.cos(sigma);
var cc = constants.cosineU * cosineSigma;
var ss = constants.sineU * sineSigma;
var lambda = Math.atan2(sineSigma * constants.sineHeading, cc - ss * constants.cosineHeading);
var l = lambda - computeDeltaLambda(constants.f, constants.sineAlpha, constants.cosineSquaredAlpha,
sigma, sineSigma, cosineSigma, cosineTwiceSigmaMidpoint);
if (defined(result)) {
result.longitude = this._start.longitude + l;
result.latitude = latitude;
result.height = 0.0;
return result;
}
return new Cartographic(this._start.longitude + l, latitude, 0.0);
};
return EllipsoidGeodesic;
});
/*global define*/
define('Core/QuadraticRealPolynomial',[
'./DeveloperError',
'./Math'
], function(
DeveloperError,
CesiumMath) {
'use strict';
/**
* Defines functions for 2nd order polynomial functions of one variable with only real coefficients.
*
* @exports QuadraticRealPolynomial
*/
var QuadraticRealPolynomial = {};
/**
* Provides the discriminant of the quadratic equation from the supplied coefficients.
*
* @param {Number} a The coefficient of the 2nd order monomial.
* @param {Number} b The coefficient of the 1st order monomial.
* @param {Number} c The coefficient of the 0th order monomial.
* @returns {Number} The value of the discriminant.
*/
QuadraticRealPolynomial.computeDiscriminant = function(a, b, c) {
if (typeof a !== 'number') {
throw new DeveloperError('a is a required number.');
}
if (typeof b !== 'number') {
throw new DeveloperError('b is a required number.');
}
if (typeof c !== 'number') {
throw new DeveloperError('c is a required number.');
}
var discriminant = b * b - 4.0 * a * c;
return discriminant;
};
function addWithCancellationCheck(left, right, tolerance) {
var difference = left + right;
if ((CesiumMath.sign(left) !== CesiumMath.sign(right)) &&
Math.abs(difference / Math.max(Math.abs(left), Math.abs(right))) < tolerance) {
return 0.0;
}
return difference;
}
/**
* Provides the real valued roots of the quadratic polynomial with the provided coefficients.
*
* @param {Number} a The coefficient of the 2nd order monomial.
* @param {Number} b The coefficient of the 1st order monomial.
* @param {Number} c The coefficient of the 0th order monomial.
* @returns {Number[]} The real valued roots.
*/
QuadraticRealPolynomial.computeRealRoots = function(a, b, c) {
if (typeof a !== 'number') {
throw new DeveloperError('a is a required number.');
}
if (typeof b !== 'number') {
throw new DeveloperError('b is a required number.');
}
if (typeof c !== 'number') {
throw new DeveloperError('c is a required number.');
}
var ratio;
if (a === 0.0) {
if (b === 0.0) {
// Constant function: c = 0.
return [];
}
// Linear function: b * x + c = 0.
return [-c / b];
} else if (b === 0.0) {
if (c === 0.0) {
// 2nd order monomial: a * x^2 = 0.
return [0.0, 0.0];
}
var cMagnitude = Math.abs(c);
var aMagnitude = Math.abs(a);
if ((cMagnitude < aMagnitude) && (cMagnitude / aMagnitude < CesiumMath.EPSILON14)) { // c ~= 0.0.
// 2nd order monomial: a * x^2 = 0.
return [0.0, 0.0];
} else if ((cMagnitude > aMagnitude) && (aMagnitude / cMagnitude < CesiumMath.EPSILON14)) { // a ~= 0.0.
// Constant function: c = 0.
return [];
}
// a * x^2 + c = 0
ratio = -c / a;
if (ratio < 0.0) {
// Both roots are complex.
return [];
}
// Both roots are real.
var root = Math.sqrt(ratio);
return [-root, root];
} else if (c === 0.0) {
// a * x^2 + b * x = 0
ratio = -b / a;
if (ratio < 0.0) {
return [ratio, 0.0];
}
return [0.0, ratio];
}
// a * x^2 + b * x + c = 0
var b2 = b * b;
var four_ac = 4.0 * a * c;
var radicand = addWithCancellationCheck(b2, -four_ac, CesiumMath.EPSILON14);
if (radicand < 0.0) {
// Both roots are complex.
return [];
}
var q = -0.5 * addWithCancellationCheck(b, CesiumMath.sign(b) * Math.sqrt(radicand), CesiumMath.EPSILON14);
if (b > 0.0) {
return [q / a, c / q];
}
return [c / q, q / a];
};
return QuadraticRealPolynomial;
});
/*global define*/
define('Core/CubicRealPolynomial',[
'./DeveloperError',
'./QuadraticRealPolynomial'
], function(
DeveloperError,
QuadraticRealPolynomial) {
'use strict';
/**
* Defines functions for 3rd order polynomial functions of one variable with only real coefficients.
*
* @exports CubicRealPolynomial
*/
var CubicRealPolynomial = {};
/**
* Provides the discriminant of the cubic equation from the supplied coefficients.
*
* @param {Number} a The coefficient of the 3rd order monomial.
* @param {Number} b The coefficient of the 2nd order monomial.
* @param {Number} c The coefficient of the 1st order monomial.
* @param {Number} d The coefficient of the 0th order monomial.
* @returns {Number} The value of the discriminant.
*/
CubicRealPolynomial.computeDiscriminant = function(a, b, c, d) {
if (typeof a !== 'number') {
throw new DeveloperError('a is a required number.');
}
if (typeof b !== 'number') {
throw new DeveloperError('b is a required number.');
}
if (typeof c !== 'number') {
throw new DeveloperError('c is a required number.');
}
if (typeof d !== 'number') {
throw new DeveloperError('d is a required number.');
}
var a2 = a * a;
var b2 = b * b;
var c2 = c * c;
var d2 = d * d;
var discriminant = 18.0 * a * b * c * d + b2 * c2 - 27.0 * a2 * d2 - 4.0 * (a * c2 * c + b2 * b * d);
return discriminant;
};
function computeRealRoots(a, b, c, d) {
var A = a;
var B = b / 3.0;
var C = c / 3.0;
var D = d;
var AC = A * C;
var BD = B * D;
var B2 = B * B;
var C2 = C * C;
var delta1 = A * C - B2;
var delta2 = A * D - B * C;
var delta3 = B * D - C2;
var discriminant = 4.0 * delta1 * delta3 - delta2 * delta2;
var temp;
var temp1;
if (discriminant < 0.0) {
var ABar;
var CBar;
var DBar;
if (B2 * BD >= AC * C2) {
ABar = A;
CBar = delta1;
DBar = -2.0 * B * delta1 + A * delta2;
} else {
ABar = D;
CBar = delta3;
DBar = -D * delta2 + 2.0 * C * delta3;
}
var s = (DBar < 0.0) ? -1.0 : 1.0; // This is not Math.Sign()!
var temp0 = -s * Math.abs(ABar) * Math.sqrt(-discriminant);
temp1 = -DBar + temp0;
var x = temp1 / 2.0;
var p = x < 0.0 ? -Math.pow(-x, 1.0 / 3.0) : Math.pow(x, 1.0 / 3.0);
var q = (temp1 === temp0) ? -p : -CBar / p;
temp = (CBar <= 0.0) ? p + q : -DBar / (p * p + q * q + CBar);
if (B2 * BD >= AC * C2) {
return [(temp - B) / A];
}
return [-D / (temp + C)];
}
var CBarA = delta1;
var DBarA = -2.0 * B * delta1 + A * delta2;
var CBarD = delta3;
var DBarD = -D * delta2 + 2.0 * C * delta3;
var squareRootOfDiscriminant = Math.sqrt(discriminant);
var halfSquareRootOf3 = Math.sqrt(3.0) / 2.0;
var theta = Math.abs(Math.atan2(A * squareRootOfDiscriminant, -DBarA) / 3.0);
temp = 2.0 * Math.sqrt(-CBarA);
var cosine = Math.cos(theta);
temp1 = temp * cosine;
var temp3 = temp * (-cosine / 2.0 - halfSquareRootOf3 * Math.sin(theta));
var numeratorLarge = (temp1 + temp3 > 2.0 * B) ? temp1 - B : temp3 - B;
var denominatorLarge = A;
var root1 = numeratorLarge / denominatorLarge;
theta = Math.abs(Math.atan2(D * squareRootOfDiscriminant, -DBarD) / 3.0);
temp = 2.0 * Math.sqrt(-CBarD);
cosine = Math.cos(theta);
temp1 = temp * cosine;
temp3 = temp * (-cosine / 2.0 - halfSquareRootOf3 * Math.sin(theta));
var numeratorSmall = -D;
var denominatorSmall = (temp1 + temp3 < 2.0 * C) ? temp1 + C : temp3 + C;
var root3 = numeratorSmall / denominatorSmall;
var E = denominatorLarge * denominatorSmall;
var F = -numeratorLarge * denominatorSmall - denominatorLarge * numeratorSmall;
var G = numeratorLarge * numeratorSmall;
var root2 = (C * F - B * G) / (-B * F + C * E);
if (root1 <= root2) {
if (root1 <= root3) {
if (root2 <= root3) {
return [root1, root2, root3];
}
return [root1, root3, root2];
}
return [root3, root1, root2];
}
if (root1 <= root3) {
return [root2, root1, root3];
}
if (root2 <= root3) {
return [root2, root3, root1];
}
return [root3, root2, root1];
}
/**
* Provides the real valued roots of the cubic polynomial with the provided coefficients.
*
* @param {Number} a The coefficient of the 3rd order monomial.
* @param {Number} b The coefficient of the 2nd order monomial.
* @param {Number} c The coefficient of the 1st order monomial.
* @param {Number} d The coefficient of the 0th order monomial.
* @returns {Number[]} The real valued roots.
*/
CubicRealPolynomial.computeRealRoots = function(a, b, c, d) {
if (typeof a !== 'number') {
throw new DeveloperError('a is a required number.');
}
if (typeof b !== 'number') {
throw new DeveloperError('b is a required number.');
}
if (typeof c !== 'number') {
throw new DeveloperError('c is a required number.');
}
if (typeof d !== 'number') {
throw new DeveloperError('d is a required number.');
}
var roots;
var ratio;
if (a === 0.0) {
// Quadratic function: b * x^2 + c * x + d = 0.
return QuadraticRealPolynomial.computeRealRoots(b, c, d);
} else if (b === 0.0) {
if (c === 0.0) {
if (d === 0.0) {
// 3rd order monomial: a * x^3 = 0.
return [0.0, 0.0, 0.0];
}
// a * x^3 + d = 0
ratio = -d / a;
var root = (ratio < 0.0) ? -Math.pow(-ratio, 1.0 / 3.0) : Math.pow(ratio, 1.0 / 3.0);
return [root, root, root];
} else if (d === 0.0) {
// x * (a * x^2 + c) = 0.
roots = QuadraticRealPolynomial.computeRealRoots(a, 0, c);
// Return the roots in ascending order.
if (roots.Length === 0) {
return [0.0];
}
return [roots[0], 0.0, roots[1]];
}
// Deflated cubic polynomial: a * x^3 + c * x + d= 0.
return computeRealRoots(a, 0, c, d);
} else if (c === 0.0) {
if (d === 0.0) {
// x^2 * (a * x + b) = 0.
ratio = -b / a;
if (ratio < 0.0) {
return [ratio, 0.0, 0.0];
}
return [0.0, 0.0, ratio];
}
// a * x^3 + b * x^2 + d = 0.
return computeRealRoots(a, b, 0, d);
} else if (d === 0.0) {
// x * (a * x^2 + b * x + c) = 0
roots = QuadraticRealPolynomial.computeRealRoots(a, b, c);
// Return the roots in ascending order.
if (roots.length === 0) {
return [0.0];
} else if (roots[1] <= 0.0) {
return [roots[0], roots[1], 0.0];
} else if (roots[0] >= 0.0) {
return [0.0, roots[0], roots[1]];
}
return [roots[0], 0.0, roots[1]];
}
return computeRealRoots(a, b, c, d);
};
return CubicRealPolynomial;
});
/*global define*/
define('Core/QuarticRealPolynomial',[
'./CubicRealPolynomial',
'./DeveloperError',
'./Math',
'./QuadraticRealPolynomial'
], function(
CubicRealPolynomial,
DeveloperError,
CesiumMath,
QuadraticRealPolynomial) {
'use strict';
/**
* Defines functions for 4th order polynomial functions of one variable with only real coefficients.
*
* @exports QuarticRealPolynomial
*/
var QuarticRealPolynomial = {};
/**
* Provides the discriminant of the quartic equation from the supplied coefficients.
*
* @param {Number} a The coefficient of the 4th order monomial.
* @param {Number} b The coefficient of the 3rd order monomial.
* @param {Number} c The coefficient of the 2nd order monomial.
* @param {Number} d The coefficient of the 1st order monomial.
* @param {Number} e The coefficient of the 0th order monomial.
* @returns {Number} The value of the discriminant.
*/
QuarticRealPolynomial.computeDiscriminant = function(a, b, c, d, e) {
if (typeof a !== 'number') {
throw new DeveloperError('a is a required number.');
}
if (typeof b !== 'number') {
throw new DeveloperError('b is a required number.');
}
if (typeof c !== 'number') {
throw new DeveloperError('c is a required number.');
}
if (typeof d !== 'number') {
throw new DeveloperError('d is a required number.');
}
if (typeof e !== 'number') {
throw new DeveloperError('e is a required number.');
}
var a2 = a * a;
var a3 = a2 * a;
var b2 = b * b;
var b3 = b2 * b;
var c2 = c * c;
var c3 = c2 * c;
var d2 = d * d;
var d3 = d2 * d;
var e2 = e * e;
var e3 = e2 * e;
var discriminant = (b2 * c2 * d2 - 4.0 * b3 * d3 - 4.0 * a * c3 * d2 + 18 * a * b * c * d3 - 27.0 * a2 * d2 * d2 + 256.0 * a3 * e3) +
e * (18.0 * b3 * c * d - 4.0 * b2 * c3 + 16.0 * a * c2 * c2 - 80.0 * a * b * c2 * d - 6.0 * a * b2 * d2 + 144.0 * a2 * c * d2) +
e2 * (144.0 * a * b2 * c - 27.0 * b2 * b2 - 128.0 * a2 * c2 - 192.0 * a2 * b * d);
return discriminant;
};
function original(a3, a2, a1, a0) {
var a3Squared = a3 * a3;
var p = a2 - 3.0 * a3Squared / 8.0;
var q = a1 - a2 * a3 / 2.0 + a3Squared * a3 / 8.0;
var r = a0 - a1 * a3 / 4.0 + a2 * a3Squared / 16.0 - 3.0 * a3Squared * a3Squared / 256.0;
// Find the roots of the cubic equations: h^6 + 2 p h^4 + (p^2 - 4 r) h^2 - q^2 = 0.
var cubicRoots = CubicRealPolynomial.computeRealRoots(1.0, 2.0 * p, p * p - 4.0 * r, -q * q);
if (cubicRoots.length > 0) {
var temp = -a3 / 4.0;
// Use the largest positive root.
var hSquared = cubicRoots[cubicRoots.length - 1];
if (Math.abs(hSquared) < CesiumMath.EPSILON14) {
// y^4 + p y^2 + r = 0.
var roots = QuadraticRealPolynomial.computeRealRoots(1.0, p, r);
if (roots.length === 2) {
var root0 = roots[0];
var root1 = roots[1];
var y;
if (root0 >= 0.0 && root1 >= 0.0) {
var y0 = Math.sqrt(root0);
var y1 = Math.sqrt(root1);
return [temp - y1, temp - y0, temp + y0, temp + y1];
} else if (root0 >= 0.0 && root1 < 0.0) {
y = Math.sqrt(root0);
return [temp - y, temp + y];
} else if (root0 < 0.0 && root1 >= 0.0) {
y = Math.sqrt(root1);
return [temp - y, temp + y];
}
}
return [];
} else if (hSquared > 0.0) {
var h = Math.sqrt(hSquared);
var m = (p + hSquared - q / h) / 2.0;
var n = (p + hSquared + q / h) / 2.0;
// Now solve the two quadratic factors: (y^2 + h y + m)(y^2 - h y + n);
var roots1 = QuadraticRealPolynomial.computeRealRoots(1.0, h, m);
var roots2 = QuadraticRealPolynomial.computeRealRoots(1.0, -h, n);
if (roots1.length !== 0) {
roots1[0] += temp;
roots1[1] += temp;
if (roots2.length !== 0) {
roots2[0] += temp;
roots2[1] += temp;
if (roots1[1] <= roots2[0]) {
return [roots1[0], roots1[1], roots2[0], roots2[1]];
} else if (roots2[1] <= roots1[0]) {
return [roots2[0], roots2[1], roots1[0], roots1[1]];
} else if (roots1[0] >= roots2[0] && roots1[1] <= roots2[1]) {
return [roots2[0], roots1[0], roots1[1], roots2[1]];
} else if (roots2[0] >= roots1[0] && roots2[1] <= roots1[1]) {
return [roots1[0], roots2[0], roots2[1], roots1[1]];
} else if (roots1[0] > roots2[0] && roots1[0] < roots2[1]) {
return [roots2[0], roots1[0], roots2[1], roots1[1]];
}
return [roots1[0], roots2[0], roots1[1], roots2[1]];
}
return roots1;
}
if (roots2.length !== 0) {
roots2[0] += temp;
roots2[1] += temp;
return roots2;
}
return [];
}
}
return [];
}
function neumark(a3, a2, a1, a0) {
var a1Squared = a1 * a1;
var a2Squared = a2 * a2;
var a3Squared = a3 * a3;
var p = -2.0 * a2;
var q = a1 * a3 + a2Squared - 4.0 * a0;
var r = a3Squared * a0 - a1 * a2 * a3 + a1Squared;
var cubicRoots = CubicRealPolynomial.computeRealRoots(1.0, p, q, r);
if (cubicRoots.length > 0) {
// Use the most positive root
var y = cubicRoots[0];
var temp = (a2 - y);
var tempSquared = temp * temp;
var g1 = a3 / 2.0;
var h1 = temp / 2.0;
var m = tempSquared - 4.0 * a0;
var mError = tempSquared + 4.0 * Math.abs(a0);
var n = a3Squared - 4.0 * y;
var nError = a3Squared + 4.0 * Math.abs(y);
var g2;
var h2;
if (y < 0.0 || (m * nError < n * mError)) {
var squareRootOfN = Math.sqrt(n);
g2 = squareRootOfN / 2.0;
h2 = squareRootOfN === 0.0 ? 0.0 : (a3 * h1 - a1) / squareRootOfN;
} else {
var squareRootOfM = Math.sqrt(m);
g2 = squareRootOfM === 0.0 ? 0.0 : (a3 * h1 - a1) / squareRootOfM;
h2 = squareRootOfM / 2.0;
}
var G;
var g;
if (g1 === 0.0 && g2 === 0.0) {
G = 0.0;
g = 0.0;
} else if (CesiumMath.sign(g1) === CesiumMath.sign(g2)) {
G = g1 + g2;
g = y / G;
} else {
g = g1 - g2;
G = y / g;
}
var H;
var h;
if (h1 === 0.0 && h2 === 0.0) {
H = 0.0;
h = 0.0;
} else if (CesiumMath.sign(h1) === CesiumMath.sign(h2)) {
H = h1 + h2;
h = a0 / H;
} else {
h = h1 - h2;
H = a0 / h;
}
// Now solve the two quadratic factors: (y^2 + G y + H)(y^2 + g y + h);
var roots1 = QuadraticRealPolynomial.computeRealRoots(1.0, G, H);
var roots2 = QuadraticRealPolynomial.computeRealRoots(1.0, g, h);
if (roots1.length !== 0) {
if (roots2.length !== 0) {
if (roots1[1] <= roots2[0]) {
return [roots1[0], roots1[1], roots2[0], roots2[1]];
} else if (roots2[1] <= roots1[0]) {
return [roots2[0], roots2[1], roots1[0], roots1[1]];
} else if (roots1[0] >= roots2[0] && roots1[1] <= roots2[1]) {
return [roots2[0], roots1[0], roots1[1], roots2[1]];
} else if (roots2[0] >= roots1[0] && roots2[1] <= roots1[1]) {
return [roots1[0], roots2[0], roots2[1], roots1[1]];
} else if (roots1[0] > roots2[0] && roots1[0] < roots2[1]) {
return [roots2[0], roots1[0], roots2[1], roots1[1]];
} else {
return [roots1[0], roots2[0], roots1[1], roots2[1]];
}
}
return roots1;
}
if (roots2.length !== 0) {
return roots2;
}
}
return [];
}
/**
* Provides the real valued roots of the quartic polynomial with the provided coefficients.
*
* @param {Number} a The coefficient of the 4th order monomial.
* @param {Number} b The coefficient of the 3rd order monomial.
* @param {Number} c The coefficient of the 2nd order monomial.
* @param {Number} d The coefficient of the 1st order monomial.
* @param {Number} e The coefficient of the 0th order monomial.
* @returns {Number[]} The real valued roots.
*/
QuarticRealPolynomial.computeRealRoots = function(a, b, c, d, e) {
if (typeof a !== 'number') {
throw new DeveloperError('a is a required number.');
}
if (typeof b !== 'number') {
throw new DeveloperError('b is a required number.');
}
if (typeof c !== 'number') {
throw new DeveloperError('c is a required number.');
}
if (typeof d !== 'number') {
throw new DeveloperError('d is a required number.');
}
if (typeof e !== 'number') {
throw new DeveloperError('e is a required number.');
}
if (Math.abs(a) < CesiumMath.EPSILON15) {
return CubicRealPolynomial.computeRealRoots(b, c, d, e);
}
var a3 = b / a;
var a2 = c / a;
var a1 = d / a;
var a0 = e / a;
var k = (a3 < 0.0) ? 1 : 0;
k += (a2 < 0.0) ? k + 1 : k;
k += (a1 < 0.0) ? k + 1 : k;
k += (a0 < 0.0) ? k + 1 : k;
switch (k) {
case 0:
return original(a3, a2, a1, a0);
case 1:
return neumark(a3, a2, a1, a0);
case 2:
return neumark(a3, a2, a1, a0);
case 3:
return original(a3, a2, a1, a0);
case 4:
return original(a3, a2, a1, a0);
case 5:
return neumark(a3, a2, a1, a0);
case 6:
return original(a3, a2, a1, a0);
case 7:
return original(a3, a2, a1, a0);
case 8:
return neumark(a3, a2, a1, a0);
case 9:
return original(a3, a2, a1, a0);
case 10:
return original(a3, a2, a1, a0);
case 11:
return neumark(a3, a2, a1, a0);
case 12:
return original(a3, a2, a1, a0);
case 13:
return original(a3, a2, a1, a0);
case 14:
return original(a3, a2, a1, a0);
case 15:
return original(a3, a2, a1, a0);
default:
return undefined;
}
};
return QuarticRealPolynomial;
});
/*global define*/
define('Core/Ray',[
'./Cartesian3',
'./defaultValue',
'./defined',
'./DeveloperError'
], function(
Cartesian3,
defaultValue,
defined,
DeveloperError) {
'use strict';
/**
* Represents a ray that extends infinitely from the provided origin in the provided direction.
* @alias Ray
* @constructor
*
* @param {Cartesian3} [origin=Cartesian3.ZERO] The origin of the ray.
* @param {Cartesian3} [direction=Cartesian3.ZERO] The direction of the ray.
*/
function Ray(origin, direction) {
direction = Cartesian3.clone(defaultValue(direction, Cartesian3.ZERO));
if (!Cartesian3.equals(direction, Cartesian3.ZERO)) {
Cartesian3.normalize(direction, direction);
}
/**
* The origin of the ray.
* @type {Cartesian3}
* @default {@link Cartesian3.ZERO}
*/
this.origin = Cartesian3.clone(defaultValue(origin, Cartesian3.ZERO));
/**
* The direction of the ray.
* @type {Cartesian3}
*/
this.direction = direction;
}
/**
* Computes the point along the ray given by r(t) = o + t*d,
* where o is the origin of the ray and d is the direction.
*
* @param {Ray} ray The ray.
* @param {Number} t A scalar value.
* @param {Cartesian3} [result] The object in which the result will be stored.
* @returns {Cartesian3} The modified result parameter, or a new instance if none was provided.
*
* @example
* //Get the first intersection point of a ray and an ellipsoid.
* var intersection = Cesium.IntersectionTests.rayEllipsoid(ray, ellipsoid);
* var point = Cesium.Ray.getPoint(ray, intersection.start);
*/
Ray.getPoint = function(ray, t, result) {
if (!defined(ray)){
throw new DeveloperError('ray is requred');
}
if (typeof t !== 'number') {
throw new DeveloperError('t is a required number');
}
if (!defined(result)) {
result = new Cartesian3();
}
result = Cartesian3.multiplyByScalar(ray.direction, t, result);
return Cartesian3.add(ray.origin, result, result);
};
return Ray;
});
/*global define*/
define('Core/IntersectionTests',[
'./Cartesian3',
'./Cartographic',
'./defaultValue',
'./defined',
'./DeveloperError',
'./Interval',
'./Math',
'./Matrix3',
'./QuadraticRealPolynomial',
'./QuarticRealPolynomial',
'./Ray'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
DeveloperError,
Interval,
CesiumMath,
Matrix3,
QuadraticRealPolynomial,
QuarticRealPolynomial,
Ray) {
'use strict';
/**
* Functions for computing the intersection between geometries such as rays, planes, triangles, and ellipsoids.
*
* @exports IntersectionTests
*/
var IntersectionTests = {};
/**
* Computes the intersection of a ray and a plane.
*
* @param {Ray} ray The ray.
* @param {Plane} plane The plane.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersections.
*/
IntersectionTests.rayPlane = function(ray, plane, result) {
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(plane)) {
throw new DeveloperError('plane is required.');
}
if (!defined(result)) {
result = new Cartesian3();
}
var origin = ray.origin;
var direction = ray.direction;
var normal = plane.normal;
var denominator = Cartesian3.dot(normal, direction);
if (Math.abs(denominator) < CesiumMath.EPSILON15) {
// Ray is parallel to plane. The ray may be in the polygon's plane.
return undefined;
}
var t = (-plane.distance - Cartesian3.dot(normal, origin)) / denominator;
if (t < 0) {
return undefined;
}
result = Cartesian3.multiplyByScalar(direction, t, result);
return Cartesian3.add(origin, result, result);
};
var scratchEdge0 = new Cartesian3();
var scratchEdge1 = new Cartesian3();
var scratchPVec = new Cartesian3();
var scratchTVec = new Cartesian3();
var scratchQVec = new Cartesian3();
/**
* Computes the intersection of a ray and a triangle as a parametric distance along the input ray.
*
* Implements {@link https://cadxfem.org/inf/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf|
* Fast Minimum Storage Ray/Triangle Intersection} by Tomas Moller and Ben Trumbore.
*
* @memberof IntersectionTests
*
* @param {Ray} ray The ray.
* @param {Cartesian3} p0 The first vertex of the triangle.
* @param {Cartesian3} p1 The second vertex of the triangle.
* @param {Cartesian3} p2 The third vertex of the triangle.
* @param {Boolean} [cullBackFaces=false] If <code>true</code>, will only compute an intersection with the front face of the triangle
* and return undefined for intersections with the back face.
* @returns {Number} The intersection as a parametric distance along the ray, or undefined if there is no intersection.
*/
IntersectionTests.rayTriangleParametric = function(ray, p0, p1, p2, cullBackFaces) {
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(p0)) {
throw new DeveloperError('p0 is required.');
}
if (!defined(p1)) {
throw new DeveloperError('p1 is required.');
}
if (!defined(p2)) {
throw new DeveloperError('p2 is required.');
}
cullBackFaces = defaultValue(cullBackFaces, false);
var origin = ray.origin;
var direction = ray.direction;
var edge0 = Cartesian3.subtract(p1, p0, scratchEdge0);
var edge1 = Cartesian3.subtract(p2, p0, scratchEdge1);
var p = Cartesian3.cross(direction, edge1, scratchPVec);
var det = Cartesian3.dot(edge0, p);
var tvec;
var q;
var u;
var v;
var t;
if (cullBackFaces) {
if (det < CesiumMath.EPSILON6) {
return undefined;
}
tvec = Cartesian3.subtract(origin, p0, scratchTVec);
u = Cartesian3.dot(tvec, p);
if (u < 0.0 || u > det) {
return undefined;
}
q = Cartesian3.cross(tvec, edge0, scratchQVec);
v = Cartesian3.dot(direction, q);
if (v < 0.0 || u + v > det) {
return undefined;
}
t = Cartesian3.dot(edge1, q) / det;
} else {
if (Math.abs(det) < CesiumMath.EPSILON6) {
return undefined;
}
var invDet = 1.0 / det;
tvec = Cartesian3.subtract(origin, p0, scratchTVec);
u = Cartesian3.dot(tvec, p) * invDet;
if (u < 0.0 || u > 1.0) {
return undefined;
}
q = Cartesian3.cross(tvec, edge0, scratchQVec);
v = Cartesian3.dot(direction, q) * invDet;
if (v < 0.0 || u + v > 1.0) {
return undefined;
}
t = Cartesian3.dot(edge1, q) * invDet;
}
return t;
};
/**
* Computes the intersection of a ray and a triangle as a Cartesian3 coordinate.
*
* Implements {@link https://cadxfem.org/inf/Fast%20MinimumStorage%20RayTriangle%20Intersection.pdf|
* Fast Minimum Storage Ray/Triangle Intersection} by Tomas Moller and Ben Trumbore.
*
* @memberof IntersectionTests
*
* @param {Ray} ray The ray.
* @param {Cartesian3} p0 The first vertex of the triangle.
* @param {Cartesian3} p1 The second vertex of the triangle.
* @param {Cartesian3} p2 The third vertex of the triangle.
* @param {Boolean} [cullBackFaces=false] If <code>true</code>, will only compute an intersection with the front face of the triangle
* and return undefined for intersections with the back face.
* @param {Cartesian3} [result] The <code>Cartesian3</code> onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersections.
*/
IntersectionTests.rayTriangle = function(ray, p0, p1, p2, cullBackFaces, result) {
var t = IntersectionTests.rayTriangleParametric(ray, p0, p1, p2, cullBackFaces);
if (!defined(t) || t < 0.0) {
return undefined;
}
if (!defined(result)) {
result = new Cartesian3();
}
Cartesian3.multiplyByScalar(ray.direction, t, result);
return Cartesian3.add(ray.origin, result, result);
};
var scratchLineSegmentTriangleRay = new Ray();
/**
* Computes the intersection of a line segment and a triangle.
* @memberof IntersectionTests
*
* @param {Cartesian3} v0 The an end point of the line segment.
* @param {Cartesian3} v1 The other end point of the line segment.
* @param {Cartesian3} p0 The first vertex of the triangle.
* @param {Cartesian3} p1 The second vertex of the triangle.
* @param {Cartesian3} p2 The third vertex of the triangle.
* @param {Boolean} [cullBackFaces=false] If <code>true</code>, will only compute an intersection with the front face of the triangle
* and return undefined for intersections with the back face.
* @param {Cartesian3} [result] The <code>Cartesian3</code> onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersections.
*/
IntersectionTests.lineSegmentTriangle = function(v0, v1, p0, p1, p2, cullBackFaces, result) {
if (!defined(v0)) {
throw new DeveloperError('v0 is required.');
}
if (!defined(v1)) {
throw new DeveloperError('v1 is required.');
}
if (!defined(p0)) {
throw new DeveloperError('p0 is required.');
}
if (!defined(p1)) {
throw new DeveloperError('p1 is required.');
}
if (!defined(p2)) {
throw new DeveloperError('p2 is required.');
}
var ray = scratchLineSegmentTriangleRay;
Cartesian3.clone(v0, ray.origin);
Cartesian3.subtract(v1, v0, ray.direction);
Cartesian3.normalize(ray.direction, ray.direction);
var t = IntersectionTests.rayTriangleParametric(ray, p0, p1, p2, cullBackFaces);
if (!defined(t) || t < 0.0 || t > Cartesian3.distance(v0, v1)) {
return undefined;
}
if (!defined(result)) {
result = new Cartesian3();
}
Cartesian3.multiplyByScalar(ray.direction, t, result);
return Cartesian3.add(ray.origin, result, result);
};
function solveQuadratic(a, b, c, result) {
var det = b * b - 4.0 * a * c;
if (det < 0.0) {
return undefined;
} else if (det > 0.0) {
var denom = 1.0 / (2.0 * a);
var disc = Math.sqrt(det);
var root0 = (-b + disc) * denom;
var root1 = (-b - disc) * denom;
if (root0 < root1) {
result.root0 = root0;
result.root1 = root1;
} else {
result.root0 = root1;
result.root1 = root0;
}
return result;
}
var root = -b / (2.0 * a);
if (root === 0.0) {
return undefined;
}
result.root0 = result.root1 = root;
return result;
}
var raySphereRoots = {
root0 : 0.0,
root1 : 0.0
};
function raySphere(ray, sphere, result) {
if (!defined(result)) {
result = new Interval();
}
var origin = ray.origin;
var direction = ray.direction;
var center = sphere.center;
var radiusSquared = sphere.radius * sphere.radius;
var diff = Cartesian3.subtract(origin, center, scratchPVec);
var a = Cartesian3.dot(direction, direction);
var b = 2.0 * Cartesian3.dot(direction, diff);
var c = Cartesian3.magnitudeSquared(diff) - radiusSquared;
var roots = solveQuadratic(a, b, c, raySphereRoots);
if (!defined(roots)) {
return undefined;
}
result.start = roots.root0;
result.stop = roots.root1;
return result;
}
/**
* Computes the intersection points of a ray with a sphere.
* @memberof IntersectionTests
*
* @param {Ray} ray The ray.
* @param {BoundingSphere} sphere The sphere.
* @param {Interval} [result] The result onto which to store the result.
* @returns {Interval} The interval containing scalar points along the ray or undefined if there are no intersections.
*/
IntersectionTests.raySphere = function(ray, sphere, result) {
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(sphere)) {
throw new DeveloperError('sphere is required.');
}
result = raySphere(ray, sphere, result);
if (!defined(result) || result.stop < 0.0) {
return undefined;
}
result.start = Math.max(result.start, 0.0);
return result;
};
var scratchLineSegmentRay = new Ray();
/**
* Computes the intersection points of a line segment with a sphere.
* @memberof IntersectionTests
*
* @param {Cartesian3} p0 An end point of the line segment.
* @param {Cartesian3} p1 The other end point of the line segment.
* @param {BoundingSphere} sphere The sphere.
* @param {Interval} [result] The result onto which to store the result.
* @returns {Interval} The interval containing scalar points along the ray or undefined if there are no intersections.
*/
IntersectionTests.lineSegmentSphere = function(p0, p1, sphere, result) {
if (!defined(p0)) {
throw new DeveloperError('p0 is required.');
}
if (!defined(p1)) {
throw new DeveloperError('p1 is required.');
}
if (!defined(sphere)) {
throw new DeveloperError('sphere is required.');
}
var ray = scratchLineSegmentRay;
Cartesian3.clone(p0, ray.origin);
var direction = Cartesian3.subtract(p1, p0, ray.direction);
var maxT = Cartesian3.magnitude(direction);
Cartesian3.normalize(direction, direction);
result = raySphere(ray, sphere, result);
if (!defined(result) || result.stop < 0.0 || result.start > maxT) {
return undefined;
}
result.start = Math.max(result.start, 0.0);
result.stop = Math.min(result.stop, maxT);
return result;
};
var scratchQ = new Cartesian3();
var scratchW = new Cartesian3();
/**
* Computes the intersection points of a ray with an ellipsoid.
*
* @param {Ray} ray The ray.
* @param {Ellipsoid} ellipsoid The ellipsoid.
* @returns {Interval} The interval containing scalar points along the ray or undefined if there are no intersections.
*/
IntersectionTests.rayEllipsoid = function(ray, ellipsoid) {
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(ellipsoid)) {
throw new DeveloperError('ellipsoid is required.');
}
var inverseRadii = ellipsoid.oneOverRadii;
var q = Cartesian3.multiplyComponents(inverseRadii, ray.origin, scratchQ);
var w = Cartesian3.multiplyComponents(inverseRadii, ray.direction, scratchW);
var q2 = Cartesian3.magnitudeSquared(q);
var qw = Cartesian3.dot(q, w);
var difference, w2, product, discriminant, temp;
if (q2 > 1.0) {
// Outside ellipsoid.
if (qw >= 0.0) {
// Looking outward or tangent (0 intersections).
return undefined;
}
// qw < 0.0.
var qw2 = qw * qw;
difference = q2 - 1.0; // Positively valued.
w2 = Cartesian3.magnitudeSquared(w);
product = w2 * difference;
if (qw2 < product) {
// Imaginary roots (0 intersections).
return undefined;
} else if (qw2 > product) {
// Distinct roots (2 intersections).
discriminant = qw * qw - product;
temp = -qw + Math.sqrt(discriminant); // Avoid cancellation.
var root0 = temp / w2;
var root1 = difference / temp;
if (root0 < root1) {
return new Interval(root0, root1);
}
return {
start : root1,
stop : root0
};
} else {
// qw2 == product. Repeated roots (2 intersections).
var root = Math.sqrt(difference / w2);
return new Interval(root, root);
}
} else if (q2 < 1.0) {
// Inside ellipsoid (2 intersections).
difference = q2 - 1.0; // Negatively valued.
w2 = Cartesian3.magnitudeSquared(w);
product = w2 * difference; // Negatively valued.
discriminant = qw * qw - product;
temp = -qw + Math.sqrt(discriminant); // Positively valued.
return new Interval(0.0, temp / w2);
} else {
// q2 == 1.0. On ellipsoid.
if (qw < 0.0) {
// Looking inward.
w2 = Cartesian3.magnitudeSquared(w);
return new Interval(0.0, -qw / w2);
}
// qw >= 0.0. Looking outward or tangent.
return undefined;
}
};
function addWithCancellationCheck(left, right, tolerance) {
var difference = left + right;
if ((CesiumMath.sign(left) !== CesiumMath.sign(right)) &&
Math.abs(difference / Math.max(Math.abs(left), Math.abs(right))) < tolerance) {
return 0.0;
}
return difference;
}
function quadraticVectorExpression(A, b, c, x, w) {
var xSquared = x * x;
var wSquared = w * w;
var l2 = (A[Matrix3.COLUMN1ROW1] - A[Matrix3.COLUMN2ROW2]) * wSquared;
var l1 = w * (x * addWithCancellationCheck(A[Matrix3.COLUMN1ROW0], A[Matrix3.COLUMN0ROW1], CesiumMath.EPSILON15) + b.y);
var l0 = (A[Matrix3.COLUMN0ROW0] * xSquared + A[Matrix3.COLUMN2ROW2] * wSquared) + x * b.x + c;
var r1 = wSquared * addWithCancellationCheck(A[Matrix3.COLUMN2ROW1], A[Matrix3.COLUMN1ROW2], CesiumMath.EPSILON15);
var r0 = w * (x * addWithCancellationCheck(A[Matrix3.COLUMN2ROW0], A[Matrix3.COLUMN0ROW2]) + b.z);
var cosines;
var solutions = [];
if (r0 === 0.0 && r1 === 0.0) {
cosines = QuadraticRealPolynomial.computeRealRoots(l2, l1, l0);
if (cosines.length === 0) {
return solutions;
}
var cosine0 = cosines[0];
var sine0 = Math.sqrt(Math.max(1.0 - cosine0 * cosine0, 0.0));
solutions.push(new Cartesian3(x, w * cosine0, w * -sine0));
solutions.push(new Cartesian3(x, w * cosine0, w * sine0));
if (cosines.length === 2) {
var cosine1 = cosines[1];
var sine1 = Math.sqrt(Math.max(1.0 - cosine1 * cosine1, 0.0));
solutions.push(new Cartesian3(x, w * cosine1, w * -sine1));
solutions.push(new Cartesian3(x, w * cosine1, w * sine1));
}
return solutions;
}
var r0Squared = r0 * r0;
var r1Squared = r1 * r1;
var l2Squared = l2 * l2;
var r0r1 = r0 * r1;
var c4 = l2Squared + r1Squared;
var c3 = 2.0 * (l1 * l2 + r0r1);
var c2 = 2.0 * l0 * l2 + l1 * l1 - r1Squared + r0Squared;
var c1 = 2.0 * (l0 * l1 - r0r1);
var c0 = l0 * l0 - r0Squared;
if (c4 === 0.0 && c3 === 0.0 && c2 === 0.0 && c1 === 0.0) {
return solutions;
}
cosines = QuarticRealPolynomial.computeRealRoots(c4, c3, c2, c1, c0);
var length = cosines.length;
if (length === 0) {
return solutions;
}
for ( var i = 0; i < length; ++i) {
var cosine = cosines[i];
var cosineSquared = cosine * cosine;
var sineSquared = Math.max(1.0 - cosineSquared, 0.0);
var sine = Math.sqrt(sineSquared);
//var left = l2 * cosineSquared + l1 * cosine + l0;
var left;
if (CesiumMath.sign(l2) === CesiumMath.sign(l0)) {
left = addWithCancellationCheck(l2 * cosineSquared + l0, l1 * cosine, CesiumMath.EPSILON12);
} else if (CesiumMath.sign(l0) === CesiumMath.sign(l1 * cosine)) {
left = addWithCancellationCheck(l2 * cosineSquared, l1 * cosine + l0, CesiumMath.EPSILON12);
} else {
left = addWithCancellationCheck(l2 * cosineSquared + l1 * cosine, l0, CesiumMath.EPSILON12);
}
var right = addWithCancellationCheck(r1 * cosine, r0, CesiumMath.EPSILON15);
var product = left * right;
if (product < 0.0) {
solutions.push(new Cartesian3(x, w * cosine, w * sine));
} else if (product > 0.0) {
solutions.push(new Cartesian3(x, w * cosine, w * -sine));
} else if (sine !== 0.0) {
solutions.push(new Cartesian3(x, w * cosine, w * -sine));
solutions.push(new Cartesian3(x, w * cosine, w * sine));
++i;
} else {
solutions.push(new Cartesian3(x, w * cosine, w * sine));
}
}
return solutions;
}
var firstAxisScratch = new Cartesian3();
var secondAxisScratch = new Cartesian3();
var thirdAxisScratch = new Cartesian3();
var referenceScratch = new Cartesian3();
var bCart = new Cartesian3();
var bScratch = new Matrix3();
var btScratch = new Matrix3();
var diScratch = new Matrix3();
var dScratch = new Matrix3();
var cScratch = new Matrix3();
var tempMatrix = new Matrix3();
var aScratch = new Matrix3();
var sScratch = new Cartesian3();
var closestScratch = new Cartesian3();
var surfPointScratch = new Cartographic();
/**
* Provides the point along the ray which is nearest to the ellipsoid.
*
* @param {Ray} ray The ray.
* @param {Ellipsoid} ellipsoid The ellipsoid.
* @returns {Cartesian3} The nearest planetodetic point on the ray.
*/
IntersectionTests.grazingAltitudeLocation = function(ray, ellipsoid) {
if (!defined(ray)) {
throw new DeveloperError('ray is required.');
}
if (!defined(ellipsoid)) {
throw new DeveloperError('ellipsoid is required.');
}
var position = ray.origin;
var direction = ray.direction;
if (!Cartesian3.equals(position, Cartesian3.ZERO)) {
var normal = ellipsoid.geodeticSurfaceNormal(position, firstAxisScratch);
if (Cartesian3.dot(direction, normal) >= 0.0) { // The location provided is the closest point in altitude
return position;
}
}
var intersects = defined(this.rayEllipsoid(ray, ellipsoid));
// Compute the scaled direction vector.
var f = ellipsoid.transformPositionToScaledSpace(direction, firstAxisScratch);
// Constructs a basis from the unit scaled direction vector. Construct its rotation and transpose.
var firstAxis = Cartesian3.normalize(f, f);
var reference = Cartesian3.mostOrthogonalAxis(f, referenceScratch);
var secondAxis = Cartesian3.normalize(Cartesian3.cross(reference, firstAxis, secondAxisScratch), secondAxisScratch);
var thirdAxis = Cartesian3.normalize(Cartesian3.cross(firstAxis, secondAxis, thirdAxisScratch), thirdAxisScratch);
var B = bScratch;
B[0] = firstAxis.x;
B[1] = firstAxis.y;
B[2] = firstAxis.z;
B[3] = secondAxis.x;
B[4] = secondAxis.y;
B[5] = secondAxis.z;
B[6] = thirdAxis.x;
B[7] = thirdAxis.y;
B[8] = thirdAxis.z;
var B_T = Matrix3.transpose(B, btScratch);
// Get the scaling matrix and its inverse.
var D_I = Matrix3.fromScale(ellipsoid.radii, diScratch);
var D = Matrix3.fromScale(ellipsoid.oneOverRadii, dScratch);
var C = cScratch;
C[0] = 0.0;
C[1] = -direction.z;
C[2] = direction.y;
C[3] = direction.z;
C[4] = 0.0;
C[5] = -direction.x;
C[6] = -direction.y;
C[7] = direction.x;
C[8] = 0.0;
var temp = Matrix3.multiply(Matrix3.multiply(B_T, D, tempMatrix), C, tempMatrix);
var A = Matrix3.multiply(Matrix3.multiply(temp, D_I, aScratch), B, aScratch);
var b = Matrix3.multiplyByVector(temp, position, bCart);
// Solve for the solutions to the expression in standard form:
var solutions = quadraticVectorExpression(A, Cartesian3.negate(b, firstAxisScratch), 0.0, 0.0, 1.0);
var s;
var altitude;
var length = solutions.length;
if (length > 0) {
var closest = Cartesian3.clone(Cartesian3.ZERO, closestScratch);
var maximumValue = Number.NEGATIVE_INFINITY;
for ( var i = 0; i < length; ++i) {
s = Matrix3.multiplyByVector(D_I, Matrix3.multiplyByVector(B, solutions[i], sScratch), sScratch);
var v = Cartesian3.normalize(Cartesian3.subtract(s, position, referenceScratch), referenceScratch);
var dotProduct = Cartesian3.dot(v, direction);
if (dotProduct > maximumValue) {
maximumValue = dotProduct;
closest = Cartesian3.clone(s, closest);
}
}
var surfacePoint = ellipsoid.cartesianToCartographic(closest, surfPointScratch);
maximumValue = CesiumMath.clamp(maximumValue, 0.0, 1.0);
altitude = Cartesian3.magnitude(Cartesian3.subtract(closest, position, referenceScratch)) * Math.sqrt(1.0 - maximumValue * maximumValue);
altitude = intersects ? -altitude : altitude;
surfacePoint.height = altitude;
return ellipsoid.cartographicToCartesian(surfacePoint, new Cartesian3());
}
return undefined;
};
var lineSegmentPlaneDifference = new Cartesian3();
/**
* Computes the intersection of a line segment and a plane.
*
* @param {Cartesian3} endPoint0 An end point of the line segment.
* @param {Cartesian3} endPoint1 The other end point of the line segment.
* @param {Plane} plane The plane.
* @param {Cartesian3} [result] The object onto which to store the result.
* @returns {Cartesian3} The intersection point or undefined if there is no intersection.
*
* @example
* var origin = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
* var normal = ellipsoid.geodeticSurfaceNormal(origin);
* var plane = Cesium.Plane.fromPointNormal(origin, normal);
*
* var p0 = new Cesium.Cartesian3(...);
* var p1 = new Cesium.Cartesian3(...);
*
* // find the intersection of the line segment from p0 to p1 and the tangent plane at origin.
* var intersection = Cesium.IntersectionTests.lineSegmentPlane(p0, p1, plane);
*/
IntersectionTests.lineSegmentPlane = function(endPoint0, endPoint1, plane, result) {
if (!defined(endPoint0)) {
throw new DeveloperError('endPoint0 is required.');
}
if (!defined(endPoint1)) {
throw new DeveloperError('endPoint1 is required.');
}
if (!defined(plane)) {
throw new DeveloperError('plane is required.');
}
if (!defined(result)) {
result = new Cartesian3();
}
var difference = Cartesian3.subtract(endPoint1, endPoint0, lineSegmentPlaneDifference);
var normal = plane.normal;
var nDotDiff = Cartesian3.dot(normal, difference);
// check if the segment and plane are parallel
if (Math.abs(nDotDiff) < CesiumMath.EPSILON6) {
return undefined;
}
var nDotP0 = Cartesian3.dot(normal, endPoint0);
var t = -(plane.distance + nDotP0) / nDotDiff;
// intersection only if t is in [0, 1]
if (t < 0.0 || t > 1.0) {
return undefined;
}
// intersection is endPoint0 + t * (endPoint1 - endPoint0)
Cartesian3.multiplyByScalar(difference, t, result);
Cartesian3.add(endPoint0, result, result);
return result;
};
/**
* Computes the intersection of a triangle and a plane
*
* @param {Cartesian3} p0 First point of the triangle
* @param {Cartesian3} p1 Second point of the triangle
* @param {Cartesian3} p2 Third point of the triangle
* @param {Plane} plane Intersection plane
* @returns {Object} An object with properties <code>positions</code> and <code>indices</code>, which are arrays that represent three triangles that do not cross the plane. (Undefined if no intersection exists)
*
* @example
* var origin = Cesium.Cartesian3.fromDegrees(-75.59777, 40.03883);
* var normal = ellipsoid.geodeticSurfaceNormal(origin);
* var plane = Cesium.Plane.fromPointNormal(origin, normal);
*
* var p0 = new Cesium.Cartesian3(...);
* var p1 = new Cesium.Cartesian3(...);
* var p2 = new Cesium.Cartesian3(...);
*
* // convert the triangle composed of points (p0, p1, p2) to three triangles that don't cross the plane
* var triangles = Cesium.IntersectionTests.trianglePlaneIntersection(p0, p1, p2, plane);
*/
IntersectionTests.trianglePlaneIntersection = function(p0, p1, p2, plane) {
if ((!defined(p0)) ||
(!defined(p1)) ||
(!defined(p2)) ||
(!defined(plane))) {
throw new DeveloperError('p0, p1, p2, and plane are required.');
}
var planeNormal = plane.normal;
var planeD = plane.distance;
var p0Behind = (Cartesian3.dot(planeNormal, p0) + planeD) < 0.0;
var p1Behind = (Cartesian3.dot(planeNormal, p1) + planeD) < 0.0;
var p2Behind = (Cartesian3.dot(planeNormal, p2) + planeD) < 0.0;
// Given these dots products, the calls to lineSegmentPlaneIntersection
// always have defined results.
var numBehind = 0;
numBehind += p0Behind ? 1 : 0;
numBehind += p1Behind ? 1 : 0;
numBehind += p2Behind ? 1 : 0;
var u1, u2;
if (numBehind === 1 || numBehind === 2) {
u1 = new Cartesian3();
u2 = new Cartesian3();
}
if (numBehind === 1) {
if (p0Behind) {
IntersectionTests.lineSegmentPlane(p0, p1, plane, u1);
IntersectionTests.lineSegmentPlane(p0, p2, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
0, 3, 4,
// In front
1, 2, 4,
1, 4, 3
]
};
} else if (p1Behind) {
IntersectionTests.lineSegmentPlane(p1, p2, plane, u1);
IntersectionTests.lineSegmentPlane(p1, p0, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
1, 3, 4,
// In front
2, 0, 4,
2, 4, 3
]
};
} else if (p2Behind) {
IntersectionTests.lineSegmentPlane(p2, p0, plane, u1);
IntersectionTests.lineSegmentPlane(p2, p1, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
2, 3, 4,
// In front
0, 1, 4,
0, 4, 3
]
};
}
} else if (numBehind === 2) {
if (!p0Behind) {
IntersectionTests.lineSegmentPlane(p1, p0, plane, u1);
IntersectionTests.lineSegmentPlane(p2, p0, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
1, 2, 4,
1, 4, 3,
// In front
0, 3, 4
]
};
} else if (!p1Behind) {
IntersectionTests.lineSegmentPlane(p2, p1, plane, u1);
IntersectionTests.lineSegmentPlane(p0, p1, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
2, 0, 4,
2, 4, 3,
// In front
1, 3, 4
]
};
} else if (!p2Behind) {
IntersectionTests.lineSegmentPlane(p0, p2, plane, u1);
IntersectionTests.lineSegmentPlane(p1, p2, plane, u2);
return {
positions : [p0, p1, p2, u1, u2 ],
indices : [
// Behind
0, 1, 4,
0, 4, 3,
// In front
2, 3, 4
]
};
}
}
// if numBehind is 3, the triangle is completely behind the plane;
// otherwise, it is completely in front (numBehind is 0).
return undefined;
};
return IntersectionTests;
});
/*global define*/
define('Core/isArray',[
'./defined'
], function(
defined) {
'use strict';
/**
* Tests an object to see if it is an array.
* @exports isArray
*
* @param {Object} value The value to test.
* @returns {Boolean} true if the value is an array, false otherwise.
*/
var isArray = Array.isArray;
if (!defined(isArray)) {
isArray = function(value) {
return Object.prototype.toString.call(value) === '[object Array]';
};
}
return isArray;
});
/*global define*/
define('Core/Plane',[
'./Cartesian3',
'./defined',
'./DeveloperError',
'./freezeObject'
], function(
Cartesian3,
defined,
DeveloperError,
freezeObject) {
'use strict';
/**
* A plane in Hessian Normal Form defined by
* <pre>
* ax + by + cz + d = 0
* </pre>
* where (a, b, c) is the plane's <code>normal</code>, d is the signed
* <code>distance</code> to the plane, and (x, y, z) is any point on
* the plane.
*
* @alias Plane
* @constructor
*
* @param {Cartesian3} normal The plane's normal (normalized).
* @param {Number} distance The shortest distance from the origin to the plane. The sign of
* <code>distance</code> determines which side of the plane the origin
* is on. If <code>distance</code> is positive, the origin is in the half-space
* in the direction of the normal; if negative, the origin is in the half-space
* opposite to the normal; if zero, the plane passes through the origin.
*
* @example
* // The plane x=0
* var plane = new Cesium.Plane(Cesium.Cartesian3.UNIT_X, 0.0);
*/
function Plane(normal, distance) {
if (!defined(normal)) {
throw new DeveloperError('normal is required.');
}
if (!defined(distance)) {
throw new DeveloperError('distance is required.');
}
/**
* The plane's normal.
*
* @type {Cartesian3}
*/
this.normal = Cartesian3.clone(normal);
/**
* The shortest distance from the origin to the plane. The sign of
* <code>distance</code> determines which side of the plane the origin
* is on. If <code>distance</code> is positive, the origin is in the half-space
* in the direction of the normal; if negative, the origin is in the half-space
* opposite to the normal; if zero, the plane passes through the origin.
*
* @type {Number}
*/
this.distance = distance;
}
/**
* Creates a plane from a normal and a point on the plane.
*
* @param {Cartesian3} point The point on the plane.
* @param {Cartesian3} normal The plane's normal (normalized).
* @param {Plane} [result] The object onto which to store the result.
* @returns {Plane} A new plane instance or the modified result parameter.
*
* @example
* var point = Cesium.Cartesian3.fromDegrees(-72.0, 40.0);
* var normal = ellipsoid.geodeticSurfaceNormal(point);
* var tangentPlane = Cesium.Plane.fromPointNormal(point, normal);
*/
Plane.fromPointNormal = function(point, normal, result) {
if (!defined(point)) {
throw new DeveloperError('point is required.');
}
if (!defined(normal)) {
throw new DeveloperError('normal is required.');
}
var distance = -Cartesian3.dot(normal, point);
if (!defined(result)) {
return new Plane(normal, distance);
}
Cartesian3.clone(normal, result.normal);
result.distance = distance;
return result;
};
var scratchNormal = new Cartesian3();
/**
* Creates a plane from the general equation
*
* @param {Cartesian4} coefficients The plane's normal (normalized).
* @param {Plane} [result] The object onto which to store the result.
* @returns {Plane} A new plane instance or the modified result parameter.
*/
Plane.fromCartesian4 = function(coefficients, result) {
if (!defined(coefficients)) {
throw new DeveloperError('coefficients is required.');
}
var normal = Cartesian3.fromCartesian4(coefficients, scratchNormal);
var distance = coefficients.w;
if (!defined(result)) {
return new Plane(normal, distance);
} else {
Cartesian3.clone(normal, result.normal);
result.distance = distance;
return result;
}
};
/**
* Computes the signed shortest distance of a point to a plane.
* The sign of the distance determines which side of the plane the point
* is on. If the distance is positive, the point is in the half-space
* in the direction of the normal; if negative, the point is in the half-space
* opposite to the normal; if zero, the plane passes through the point.
*
* @param {Plane} plane The plane.
* @param {Cartesian3} point The point.
* @returns {Number} The signed shortest distance of the point to the plane.
*/
Plane.getPointDistance = function(plane, point) {
if (!defined(plane)) {
throw new DeveloperError('plane is required.');
}
if (!defined(point)) {
throw new DeveloperError('point is required.');
}
return Cartesian3.dot(plane.normal, point) + plane.distance;
};
/**
* A constant initialized to the XY plane passing through the origin, with normal in positive Z.
*
* @type {Plane}
* @constant
*/
Plane.ORIGIN_XY_PLANE = freezeObject(new Plane(Cartesian3.UNIT_Z, 0.0));
/**
* A constant initialized to the YZ plane passing through the origin, with normal in positive X.
*
* @type {Plane}
* @constant
*/
Plane.ORIGIN_YZ_PLANE = freezeObject(new Plane(Cartesian3.UNIT_X, 0.0));
/**
* A constant initialized to the ZX plane passing through the origin, with normal in positive Y.
*
* @type {Plane}
* @constant
*/
Plane.ORIGIN_ZX_PLANE = freezeObject(new Plane(Cartesian3.UNIT_Y, 0.0));
return Plane;
});
/*global define*/
define('Core/PolylinePipeline',[
'./Cartesian3',
'./Cartographic',
'./defaultValue',
'./defined',
'./DeveloperError',
'./Ellipsoid',
'./EllipsoidGeodesic',
'./IntersectionTests',
'./isArray',
'./Math',
'./Matrix4',
'./Plane'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
DeveloperError,
Ellipsoid,
EllipsoidGeodesic,
IntersectionTests,
isArray,
CesiumMath,
Matrix4,
Plane) {
'use strict';
/**
* @private
*/
var PolylinePipeline = {};
PolylinePipeline.numberOfPoints = function(p0, p1, minDistance) {
var distance = Cartesian3.distance(p0, p1);
return Math.ceil(distance / minDistance);
};
var cartoScratch = new Cartographic();
PolylinePipeline.extractHeights = function(positions, ellipsoid) {
var length = positions.length;
var heights = new Array(length);
for (var i = 0; i < length; i++) {
var p = positions[i];
heights[i] = ellipsoid.cartesianToCartographic(p, cartoScratch).height;
}
return heights;
};
var wrapLongitudeInversMatrix = new Matrix4();
var wrapLongitudeOrigin = new Cartesian3();
var wrapLongitudeXZNormal = new Cartesian3();
var wrapLongitudeXZPlane = new Plane(Cartesian3.ZERO, 0.0);
var wrapLongitudeYZNormal = new Cartesian3();
var wrapLongitudeYZPlane = new Plane(Cartesian3.ZERO, 0.0);
var wrapLongitudeIntersection = new Cartesian3();
var wrapLongitudeOffset = new Cartesian3();
var subdivideHeightsScratchArray = [];
function subdivideHeights(numPoints, h0, h1) {
var heights = subdivideHeightsScratchArray;
heights.length = numPoints;
var i;
if (h0 === h1) {
for (i = 0; i < numPoints; i++) {
heights[i] = h0;
}
return heights;
}
var dHeight = h1 - h0;
var heightPerVertex = dHeight / numPoints;
for (i = 0; i < numPoints; i++) {
var h = h0 + i*heightPerVertex;
heights[i] = h;
}
return heights;
}
var carto1 = new Cartographic();
var carto2 = new Cartographic();
var cartesian = new Cartesian3();
var scaleFirst = new Cartesian3();
var scaleLast = new Cartesian3();
var ellipsoidGeodesic = new EllipsoidGeodesic();
//Returns subdivided line scaled to ellipsoid surface starting at p1 and ending at p2.
//Result includes p1, but not include p2. This function is called for a sequence of line segments,
//and this prevents duplication of end point.
function generateCartesianArc(p0, p1, minDistance, ellipsoid, h0, h1, array, offset) {
var first = ellipsoid.scaleToGeodeticSurface(p0, scaleFirst);
var last = ellipsoid.scaleToGeodeticSurface(p1, scaleLast);
var numPoints = PolylinePipeline.numberOfPoints(p0, p1, minDistance);
var start = ellipsoid.cartesianToCartographic(first, carto1);
var end = ellipsoid.cartesianToCartographic(last, carto2);
var heights = subdivideHeights(numPoints, h0, h1);
ellipsoidGeodesic.setEndPoints(start, end);
var surfaceDistanceBetweenPoints = ellipsoidGeodesic.surfaceDistance / numPoints;
var index = offset;
start.height = h0;
var cart = ellipsoid.cartographicToCartesian(start, cartesian);
Cartesian3.pack(cart, array, index);
index += 3;
for (var i = 1; i < numPoints; i++) {
var carto = ellipsoidGeodesic.interpolateUsingSurfaceDistance(i * surfaceDistanceBetweenPoints, carto2);
carto.height = heights[i];
cart = ellipsoid.cartographicToCartesian(carto, cartesian);
Cartesian3.pack(cart, array, index);
index += 3;
}
return index;
}
/**
* Breaks a {@link Polyline} into segments such that it does not cross the ±180 degree meridian of an ellipsoid.
*
* @param {Cartesian3[]} positions The polyline's Cartesian positions.
* @param {Matrix4} [modelMatrix=Matrix4.IDENTITY] The polyline's model matrix. Assumed to be an affine
* transformation matrix, where the upper left 3x3 elements are a rotation matrix, and
* the upper three elements in the fourth column are the translation. The bottom row is assumed to be [0, 0, 0, 1].
* The matrix is not verified to be in the proper form.
* @returns {Object} An object with a <code>positions</code> property that is an array of positions and a
* <code>segments</code> property.
*
*
* @example
* var polylines = new Cesium.PolylineCollection();
* var polyline = polylines.add(...);
* var positions = polyline.positions;
* var modelMatrix = polylines.modelMatrix;
* var segments = Cesium.PolylinePipeline.wrapLongitude(positions, modelMatrix);
*
* @see PolygonPipeline.wrapLongitude
* @see Polyline
* @see PolylineCollection
*/
PolylinePipeline.wrapLongitude = function(positions, modelMatrix) {
var cartesians = [];
var segments = [];
if (defined(positions) && positions.length > 0) {
modelMatrix = defaultValue(modelMatrix, Matrix4.IDENTITY);
var inverseModelMatrix = Matrix4.inverseTransformation(modelMatrix, wrapLongitudeInversMatrix);
var origin = Matrix4.multiplyByPoint(inverseModelMatrix, Cartesian3.ZERO, wrapLongitudeOrigin);
var xzNormal = Matrix4.multiplyByPointAsVector(inverseModelMatrix, Cartesian3.UNIT_Y, wrapLongitudeXZNormal);
var xzPlane = Plane.fromPointNormal(origin, xzNormal, wrapLongitudeXZPlane);
var yzNormal = Matrix4.multiplyByPointAsVector(inverseModelMatrix, Cartesian3.UNIT_X, wrapLongitudeYZNormal);
var yzPlane = Plane.fromPointNormal(origin, yzNormal, wrapLongitudeYZPlane);
var count = 1;
cartesians.push(Cartesian3.clone(positions[0]));
var prev = cartesians[0];
var length = positions.length;
for (var i = 1; i < length; ++i) {
var cur = positions[i];
// intersects the IDL if either endpoint is on the negative side of the yz-plane
if (Plane.getPointDistance(yzPlane, prev) < 0.0 || Plane.getPointDistance(yzPlane, cur) < 0.0) {
// and intersects the xz-plane
var intersection = IntersectionTests.lineSegmentPlane(prev, cur, xzPlane, wrapLongitudeIntersection);
if (defined(intersection)) {
// move point on the xz-plane slightly away from the plane
var offset = Cartesian3.multiplyByScalar(xzNormal, 5.0e-9, wrapLongitudeOffset);
if (Plane.getPointDistance(xzPlane, prev) < 0.0) {
Cartesian3.negate(offset, offset);
}
cartesians.push(Cartesian3.add(intersection, offset, new Cartesian3()));
segments.push(count + 1);
Cartesian3.negate(offset, offset);
cartesians.push(Cartesian3.add(intersection, offset, new Cartesian3()));
count = 1;
}
}
cartesians.push(Cartesian3.clone(positions[i]));
count++;
prev = cur;
}
segments.push(count);
}
return {
positions : cartesians,
lengths : segments
};
};
/**
* Subdivides polyline and raises all points to the specified height. Returns an array of numbers to represent the positions.
* @param {Cartesian3[]} options.positions The array of type {Cartesian3} representing positions.
* @param {Number|Number[]} [options.height=0.0] A number or array of numbers representing the heights of each position.
* @param {Number} [options.granularity = CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
* @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the positions lie.
* @returns {Number[]} A new array of positions of type {Number} that have been subdivided and raised to the surface of the ellipsoid.
*
* @example
* var positions = Cesium.Cartesian3.fromDegreesArray([
* -105.0, 40.0,
* -100.0, 38.0,
* -105.0, 35.0,
* -100.0, 32.0
* ]);
* var surfacePositions = Cesium.PolylinePipeline.generateArc({
* positons: positions
* });
*/
PolylinePipeline.generateArc = function(options) {
if (!defined(options)) {
options = {};
}
var positions = options.positions;
if (!defined(positions)) {
throw new DeveloperError('options.positions is required.');
}
var length = positions.length;
var ellipsoid = defaultValue(options.ellipsoid, Ellipsoid.WGS84);
var height = defaultValue(options.height, 0);
var hasHeightArray = isArray(height);
if (length < 1) {
return [];
} else if (length === 1) {
var p = ellipsoid.scaleToGeodeticSurface(positions[0], scaleFirst);
height = hasHeightArray ? height[0] : height;
if (height !== 0) {
var n = ellipsoid.geodeticSurfaceNormal(p, cartesian);
Cartesian3.multiplyByScalar(n, height, n);
Cartesian3.add(p, n, p);
}
return [p.x, p.y, p.z];
}
var minDistance = options.minDistance;
if (!defined(minDistance)) {
var granularity = defaultValue(options.granularity, CesiumMath.RADIANS_PER_DEGREE);
minDistance = CesiumMath.chordLength(granularity, ellipsoid.maximumRadius);
}
var numPoints = 0;
var i;
for (i = 0; i < length -1; i++) {
numPoints += PolylinePipeline.numberOfPoints(positions[i], positions[i+1], minDistance);
}
var arrayLength = (numPoints + 1) * 3;
var newPositions = new Array(arrayLength);
var offset = 0;
for (i = 0; i < length - 1; i++) {
var p0 = positions[i];
var p1 = positions[i + 1];
var h0 = hasHeightArray ? height[i] : height;
var h1 = hasHeightArray ? height[i + 1] : height;
offset = generateCartesianArc(p0, p1, minDistance, ellipsoid, h0, h1, newPositions, offset);
}
subdivideHeightsScratchArray.length = 0;
var lastPoint = positions[length - 1];
var carto = ellipsoid.cartesianToCartographic(lastPoint, carto1);
carto.height = hasHeightArray ? height[length - 1] : height;
var cart = ellipsoid.cartographicToCartesian(carto, cartesian);
Cartesian3.pack(cart, newPositions, arrayLength - 3);
return newPositions;
};
/**
* Subdivides polyline and raises all points to the specified height. Returns an array of new {Cartesian3} positions.
* @param {Cartesian3[]} options.positions The array of type {Cartesian3} representing positions.
* @param {Number|Number[]} [options.height=0.0] A number or array of numbers representing the heights of each position.
* @param {Number} [options.granularity = CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
* @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the positions lie.
* @returns {Cartesian3[]} A new array of cartesian3 positions that have been subdivided and raised to the surface of the ellipsoid.
*
* @example
* var positions = Cesium.Cartesian3.fromDegreesArray([
* -105.0, 40.0,
* -100.0, 38.0,
* -105.0, 35.0,
* -100.0, 32.0
* ]);
* var surfacePositions = Cesium.PolylinePipeline.generateCartesianArc({
* positons: positions
* });
*/
PolylinePipeline.generateCartesianArc = function(options) {
var numberArray = PolylinePipeline.generateArc(options);
var size = numberArray.length/3;
var newPositions = new Array(size);
for (var i = 0; i < size; i++) {
newPositions[i] = Cartesian3.unpack(numberArray, i*3);
}
return newPositions;
};
return PolylinePipeline;
});
/*global define*/
define('Core/VertexFormat',[
'./defaultValue',
'./defined',
'./DeveloperError',
'./freezeObject'
], function(
defaultValue,
defined,
DeveloperError,
freezeObject) {
'use strict';
/**
* A vertex format defines what attributes make up a vertex. A VertexFormat can be provided
* to a {@link Geometry} to request that certain properties be computed, e.g., just position,
* position and normal, etc.
*
* @param {Object} [options] An object with boolean properties corresponding to VertexFormat properties as shown in the code example.
*
* @alias VertexFormat
* @constructor
*
* @example
* // Create a vertex format with position and 2D texture coordinate attributes.
* var format = new Cesium.VertexFormat({
* position : true,
* st : true
* });
*
* @see Geometry#attributes
* @see Packable
*/
function VertexFormat(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
/**
* When <code>true</code>, the vertex has a 3D position attribute.
* <p>
* 64-bit floating-point (for precision). 3 components per attribute.
* </p>
*
* @type Boolean
*
* @default false
*/
this.position = defaultValue(options.position, false);
/**
* When <code>true</code>, the vertex has a normal attribute (normalized), which is commonly used for lighting.
* <p>
* 32-bit floating-point. 3 components per attribute.
* </p>
*
* @type Boolean
*
* @default false
*/
this.normal = defaultValue(options.normal, false);
/**
* When <code>true</code>, the vertex has a 2D texture coordinate attribute.
* <p>
* 32-bit floating-point. 2 components per attribute
* </p>
*
* @type Boolean
*
* @default false
*/
this.st = defaultValue(options.st, false);
/**
* When <code>true</code>, the vertex has a bitangent attribute (normalized), which is used for tangent-space effects like bump mapping.
* <p>
* 32-bit floating-point. 3 components per attribute.
* </p>
*
* @type Boolean
*
* @default false
*/
this.bitangent = defaultValue(options.bitangent, false);
/**
* When <code>true</code>, the vertex has a tangent attribute (normalized), which is used for tangent-space effects like bump mapping.
* <p>
* 32-bit floating-point. 3 components per attribute.
* </p>
*
* @type Boolean
*
* @default false
*/
this.tangent = defaultValue(options.tangent, false);
/**
* When <code>true</code>, the vertex has an RGB color attribute.
* <p>
* 8-bit unsigned byte. 3 components per attribute.
* </p>
*
* @type Boolean
*
* @default false
*/
this.color = defaultValue(options.color, false);
}
/**
* An immutable vertex format with only a position attribute.
*
* @type {VertexFormat}
* @constant
*
* @see VertexFormat#position
*/
VertexFormat.POSITION_ONLY = freezeObject(new VertexFormat({
position : true
}));
/**
* An immutable vertex format with position and normal attributes.
* This is compatible with per-instance color appearances like {@link PerInstanceColorAppearance}.
*
* @type {VertexFormat}
* @constant
*
* @see VertexFormat#position
* @see VertexFormat#normal
*/
VertexFormat.POSITION_AND_NORMAL = freezeObject(new VertexFormat({
position : true,
normal : true
}));
/**
* An immutable vertex format with position, normal, and st attributes.
* This is compatible with {@link MaterialAppearance} when {@link MaterialAppearance#materialSupport}
* is <code>TEXTURED/code>.
*
* @type {VertexFormat}
* @constant
*
* @see VertexFormat#position
* @see VertexFormat#normal
* @see VertexFormat#st
*/
VertexFormat.POSITION_NORMAL_AND_ST = freezeObject(new VertexFormat({
position : true,
normal : true,
st : true
}));
/**
* An immutable vertex format with position and st attributes.
* This is compatible with {@link EllipsoidSurfaceAppearance}.
*
* @type {VertexFormat}
* @constant
*
* @see VertexFormat#position
* @see VertexFormat#st
*/
VertexFormat.POSITION_AND_ST = freezeObject(new VertexFormat({
position : true,
st : true
}));
/**
* An immutable vertex format with position and color attributes.
*
* @type {VertexFormat}
* @constant
*
* @see VertexFormat#position
* @see VertexFormat#color
*/
VertexFormat.POSITION_AND_COLOR = freezeObject(new VertexFormat({
position : true,
color : true
}));
/**
* An immutable vertex format with well-known attributes: position, normal, st, tangent, and bitangent.
*
* @type {VertexFormat}
* @constant
*
* @see VertexFormat#position
* @see VertexFormat#normal
* @see VertexFormat#st
* @see VertexFormat#tangent
* @see VertexFormat#bitangent
*/
VertexFormat.ALL = freezeObject(new VertexFormat({
position : true,
normal : true,
st : true,
tangent : true,
bitangent : true
}));
/**
* An immutable vertex format with position, normal, and st attributes.
* This is compatible with most appearances and materials; however
* normal and st attributes are not always required. When this is
* known in advance, another <code>VertexFormat</code> should be used.
*
* @type {VertexFormat}
* @constant
*
* @see VertexFormat#position
* @see VertexFormat#normal
*/
VertexFormat.DEFAULT = VertexFormat.POSITION_NORMAL_AND_ST;
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
VertexFormat.packedLength = 6;
/**
* Stores the provided instance into the provided array.
*
* @param {VertexFormat} 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
*/
VertexFormat.pack = function(value, array, startingIndex) {
if (!defined(value)) {
throw new DeveloperError('value is required');
}
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
array[startingIndex++] = value.position ? 1.0 : 0.0;
array[startingIndex++] = value.normal ? 1.0 : 0.0;
array[startingIndex++] = value.st ? 1.0 : 0.0;
array[startingIndex++] = value.tangent ? 1.0 : 0.0;
array[startingIndex++] = value.bitangent ? 1.0 : 0.0;
array[startingIndex++] = value.color ? 1.0 : 0.0;
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 {VertexFormat} [result] The object into which to store the result.
* @returns {VertexFormat} The modified result parameter or a new VertexFormat instance if one was not provided.
*/
VertexFormat.unpack = function(array, startingIndex, result) {
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new VertexFormat();
}
result.position = array[startingIndex++] === 1.0;
result.normal = array[startingIndex++] === 1.0;
result.st = array[startingIndex++] === 1.0;
result.tangent = array[startingIndex++] === 1.0;
result.bitangent = array[startingIndex++] === 1.0;
result.color = array[startingIndex++] === 1.0;
return result;
};
/**
* Duplicates a VertexFormat instance.
*
* @param {VertexFormat} vertexFormat The vertex format to duplicate.
* @param {VertexFormat} [result] The object onto which to store the result.
* @returns {VertexFormat} The modified result parameter or a new VertexFormat instance if one was not provided. (Returns undefined if vertexFormat is undefined)
*/
VertexFormat.clone = function(vertexFormat, result) {
if (!defined(vertexFormat)) {
return undefined;
}
if (!defined(result)) {
result = new VertexFormat();
}
result.position = vertexFormat.position;
result.normal = vertexFormat.normal;
result.st = vertexFormat.st;
result.tangent = vertexFormat.tangent;
result.bitangent = vertexFormat.bitangent;
result.color = vertexFormat.color;
return result;
};
return VertexFormat;
});
/*global define*/
define('Core/PolylineGeometry',[
'./arrayRemoveDuplicates',
'./BoundingSphere',
'./Cartesian3',
'./Color',
'./ComponentDatatype',
'./defaultValue',
'./defined',
'./DeveloperError',
'./Ellipsoid',
'./Geometry',
'./GeometryAttribute',
'./GeometryAttributes',
'./GeometryType',
'./IndexDatatype',
'./Math',
'./PolylinePipeline',
'./PrimitiveType',
'./VertexFormat'
], function(
arrayRemoveDuplicates,
BoundingSphere,
Cartesian3,
Color,
ComponentDatatype,
defaultValue,
defined,
DeveloperError,
Ellipsoid,
Geometry,
GeometryAttribute,
GeometryAttributes,
GeometryType,
IndexDatatype,
CesiumMath,
PolylinePipeline,
PrimitiveType,
VertexFormat) {
'use strict';
var scratchInterpolateColorsArray = [];
function interpolateColors(p0, p1, color0, color1, numPoints) {
var colors = scratchInterpolateColorsArray;
colors.length = numPoints;
var i;
var r0 = color0.red;
var g0 = color0.green;
var b0 = color0.blue;
var a0 = color0.alpha;
var r1 = color1.red;
var g1 = color1.green;
var b1 = color1.blue;
var a1 = color1.alpha;
if (Color.equals(color0, color1)) {
for (i = 0; i < numPoints; i++) {
colors[i] = Color.clone(color0);
}
return colors;
}
var redPerVertex = (r1 - r0) / numPoints;
var greenPerVertex = (g1 - g0) / numPoints;
var bluePerVertex = (b1 - b0) / numPoints;
var alphaPerVertex = (a1 - a0) / numPoints;
for (i = 0; i < numPoints; i++) {
colors[i] = new Color(r0 + i * redPerVertex, g0 + i * greenPerVertex, b0 + i * bluePerVertex, a0 + i * alphaPerVertex);
}
return colors;
}
/**
* A description of a polyline modeled as a line strip; the first two positions define a line segment,
* and each additional position defines a line segment from the previous position. The polyline is capable of
* displaying with a material.
*
* @alias PolylineGeometry
* @constructor
*
* @param {Object} options Object with the following properties:
* @param {Cartesian3[]} options.positions An array of {@link Cartesian3} defining the positions in the polyline as a line strip.
* @param {Number} [options.width=1.0] The width in pixels.
* @param {Color[]} [options.colors] An Array of {@link Color} defining the per vertex or per segment colors.
* @param {Boolean} [options.colorsPerVertex=false] A boolean that determines whether the colors will be flat across each segment of the line or interpolated across the vertices.
* @param {Boolean} [options.followSurface=true] A boolean that determines whether positions will be adjusted to the surface of the ellipsoid via a great arc.
* @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude if options.followSurface=true. Determines the number of positions in the buffer.
* @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
* @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid to be used as a reference.
*
* @exception {DeveloperError} At least two positions are required.
* @exception {DeveloperError} width must be greater than or equal to one.
* @exception {DeveloperError} colors has an invalid length.
*
* @see PolylineGeometry#createGeometry
*
* @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Polyline.html|Cesium Sandcastle Polyline Demo}
*
* @example
* // A polyline with two connected line segments
* var polyline = new Cesium.PolylineGeometry({
* positions : Cesium.Cartesian3.fromDegreesArray([
* 0.0, 0.0,
* 5.0, 0.0,
* 5.0, 5.0
* ]),
* width : 10.0
* });
* var geometry = Cesium.PolylineGeometry.createGeometry(polyline);
*/
function PolylineGeometry(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var positions = options.positions;
var colors = options.colors;
var width = defaultValue(options.width, 1.0);
var colorsPerVertex = defaultValue(options.colorsPerVertex, false);
if ((!defined(positions)) || (positions.length < 2)) {
throw new DeveloperError('At least two positions are required.');
}
if (typeof width !== 'number') {
throw new DeveloperError('width must be a number');
}
if (defined(colors) && ((colorsPerVertex && colors.length < positions.length) || (!colorsPerVertex && colors.length < positions.length - 1))) {
throw new DeveloperError('colors has an invalid length.');
}
this._positions = positions;
this._colors = colors;
this._width = width;
this._colorsPerVertex = colorsPerVertex;
this._vertexFormat = VertexFormat.clone(defaultValue(options.vertexFormat, VertexFormat.DEFAULT));
this._followSurface = defaultValue(options.followSurface, true);
this._granularity = defaultValue(options.granularity, CesiumMath.RADIANS_PER_DEGREE);
this._ellipsoid = Ellipsoid.clone(defaultValue(options.ellipsoid, Ellipsoid.WGS84));
this._workerName = 'createPolylineGeometry';
var numComponents = 1 + positions.length * Cartesian3.packedLength;
numComponents += defined(colors) ? 1 + colors.length * Color.packedLength : 1;
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
this.packedLength = numComponents + Ellipsoid.packedLength + VertexFormat.packedLength + 4;
}
/**
* Stores the provided instance into the provided array.
*
* @param {PolylineGeometry} 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
*/
PolylineGeometry.pack = function(value, array, startingIndex) {
if (!defined(value)) {
throw new DeveloperError('value is required');
}
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
var i;
var positions = value._positions;
var length = positions.length;
array[startingIndex++] = length;
for (i = 0; i < length; ++i, startingIndex += Cartesian3.packedLength) {
Cartesian3.pack(positions[i], array, startingIndex);
}
var colors = value._colors;
length = defined(colors) ? colors.length : 0.0;
array[startingIndex++] = length;
for (i = 0; i < length; ++i, startingIndex += Color.packedLength) {
Color.pack(colors[i], array, startingIndex);
}
Ellipsoid.pack(value._ellipsoid, array, startingIndex);
startingIndex += Ellipsoid.packedLength;
VertexFormat.pack(value._vertexFormat, array, startingIndex);
startingIndex += VertexFormat.packedLength;
array[startingIndex++] = value._width;
array[startingIndex++] = value._colorsPerVertex ? 1.0 : 0.0;
array[startingIndex++] = value._followSurface ? 1.0 : 0.0;
array[startingIndex] = value._granularity;
return array;
};
var scratchEllipsoid = Ellipsoid.clone(Ellipsoid.UNIT_SPHERE);
var scratchVertexFormat = new VertexFormat();
var scratchOptions = {
positions : undefined,
colors : undefined,
ellipsoid : scratchEllipsoid,
vertexFormat : scratchVertexFormat,
width : undefined,
colorsPerVertex : undefined,
followSurface : undefined,
granularity : undefined
};
/**
* 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 {PolylineGeometry} [result] The object into which to store the result.
* @returns {PolylineGeometry} The modified result parameter or a new PolylineGeometry instance if one was not provided.
*/
PolylineGeometry.unpack = function(array, startingIndex, result) {
if (!defined(array)) {
throw new DeveloperError('array is required');
}
startingIndex = defaultValue(startingIndex, 0);
var i;
var length = array[startingIndex++];
var positions = new Array(length);
for (i = 0; i < length; ++i, startingIndex += Cartesian3.packedLength) {
positions[i] = Cartesian3.unpack(array, startingIndex);
}
length = array[startingIndex++];
var colors = length > 0 ? new Array(length) : undefined;
for (i = 0; i < length; ++i, startingIndex += Color.packedLength) {
colors[i] = Color.unpack(array, startingIndex);
}
var ellipsoid = Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
startingIndex += Ellipsoid.packedLength;
var vertexFormat = VertexFormat.unpack(array, startingIndex, scratchVertexFormat);
startingIndex += VertexFormat.packedLength;
var width = array[startingIndex++];
var colorsPerVertex = array[startingIndex++] === 1.0;
var followSurface = array[startingIndex++] === 1.0;
var granularity = array[startingIndex];
if (!defined(result)) {
scratchOptions.positions = positions;
scratchOptions.colors = colors;
scratchOptions.width = width;
scratchOptions.colorsPerVertex = colorsPerVertex;
scratchOptions.followSurface = followSurface;
scratchOptions.granularity = granularity;
return new PolylineGeometry(scratchOptions);
}
result._positions = positions;
result._colors = colors;
result._ellipsoid = Ellipsoid.clone(ellipsoid, result._ellipsoid);
result._vertexFormat = VertexFormat.clone(vertexFormat, result._vertexFormat);
result._width = width;
result._colorsPerVertex = colorsPerVertex;
result._followSurface = followSurface;
result._granularity = granularity;
return result;
};
var scratchCartesian3 = new Cartesian3();
var scratchPosition = new Cartesian3();
var scratchPrevPosition = new Cartesian3();
var scratchNextPosition = new Cartesian3();
/**
* Computes the geometric representation of a polyline, including its vertices, indices, and a bounding sphere.
*
* @param {PolylineGeometry} polylineGeometry A description of the polyline.
* @returns {Geometry|undefined} The computed vertices and indices.
*/
PolylineGeometry.createGeometry = function(polylineGeometry) {
var width = polylineGeometry._width;
var vertexFormat = polylineGeometry._vertexFormat;
var colors = polylineGeometry._colors;
var colorsPerVertex = polylineGeometry._colorsPerVertex;
var followSurface = polylineGeometry._followSurface;
var granularity = polylineGeometry._granularity;
var ellipsoid = polylineGeometry._ellipsoid;
var i;
var j;
var k;
var positions = arrayRemoveDuplicates(polylineGeometry._positions, Cartesian3.equalsEpsilon);
var positionsLength = positions.length;
// A width of a pixel or less is not a valid geometry, but in order to support external data
// that may have errors we treat this as an empty geometry.
if (positionsLength < 2 || width <= 0.0) {
return undefined;
}
if (followSurface) {
var heights = PolylinePipeline.extractHeights(positions, ellipsoid);
var minDistance = CesiumMath.chordLength(granularity, ellipsoid.maximumRadius);
if (defined(colors)) {
var colorLength = 1;
for (i = 0; i < positionsLength - 1; ++i) {
colorLength += PolylinePipeline.numberOfPoints(positions[i], positions[i+1], minDistance);
}
var newColors = new Array(colorLength);
var newColorIndex = 0;
for (i = 0; i < positionsLength - 1; ++i) {
var p0 = positions[i];
var p1 = positions[i+1];
var c0 = colors[i];
var numColors = PolylinePipeline.numberOfPoints(p0, p1, minDistance);
if (colorsPerVertex && i < colorLength) {
var c1 = colors[i+1];
var interpolatedColors = interpolateColors(p0, p1, c0, c1, numColors);
var interpolatedColorsLength = interpolatedColors.length;
for (j = 0; j < interpolatedColorsLength; ++j) {
newColors[newColorIndex++] = interpolatedColors[j];
}
} else {
for (j = 0; j < numColors; ++j) {
newColors[newColorIndex++] = Color.clone(c0);
}
}
}
newColors[newColorIndex] = Color.clone(colors[colors.length-1]);
colors = newColors;
scratchInterpolateColorsArray.length = 0;
}
positions = PolylinePipeline.generateCartesianArc({
positions: positions,
minDistance: minDistance,
ellipsoid: ellipsoid,
height: heights
});
}
positionsLength = positions.length;
var size = positionsLength * 4.0 - 4.0;
var finalPositions = new Float64Array(size * 3);
var prevPositions = new Float64Array(size * 3);
var nextPositions = new Float64Array(size * 3);
var expandAndWidth = new Float32Array(size * 2);
var st = vertexFormat.st ? new Float32Array(size * 2) : undefined;
var finalColors = defined(colors) ? new Uint8Array(size * 4) : undefined;
var positionIndex = 0;
var expandAndWidthIndex = 0;
var stIndex = 0;
var colorIndex = 0;
var position;
for (j = 0; j < positionsLength; ++j) {
if (j === 0) {
position = scratchCartesian3;
Cartesian3.subtract(positions[0], positions[1], position);
Cartesian3.add(positions[0], position, position);
} else {
position = positions[j - 1];
}
Cartesian3.clone(position, scratchPrevPosition);
Cartesian3.clone(positions[j], scratchPosition);
if (j === positionsLength - 1) {
position = scratchCartesian3;
Cartesian3.subtract(positions[positionsLength - 1], positions[positionsLength - 2], position);
Cartesian3.add(positions[positionsLength - 1], position, position);
} else {
position = positions[j + 1];
}
Cartesian3.clone(position, scratchNextPosition);
var color0, color1;
if (defined(finalColors)) {
if (j !== 0 && !colorsPerVertex) {
color0 = colors[j - 1];
} else {
color0 = colors[j];
}
if (j !== positionsLength - 1) {
color1 = colors[j];
}
}
var startK = j === 0 ? 2 : 0;
var endK = j === positionsLength - 1 ? 2 : 4;
for (k = startK; k < endK; ++k) {
Cartesian3.pack(scratchPosition, finalPositions, positionIndex);
Cartesian3.pack(scratchPrevPosition, prevPositions, positionIndex);
Cartesian3.pack(scratchNextPosition, nextPositions, positionIndex);
positionIndex += 3;
var direction = (k - 2 < 0) ? -1.0 : 1.0;
expandAndWidth[expandAndWidthIndex++] = 2 * (k % 2) - 1; // expand direction
expandAndWidth[expandAndWidthIndex++] = direction * width;
if (vertexFormat.st) {
st[stIndex++] = j / (positionsLength - 1);
st[stIndex++] = Math.max(expandAndWidth[expandAndWidthIndex - 2], 0.0);
}
if (defined(finalColors)) {
var color = (k < 2) ? color0 : color1;
finalColors[colorIndex++] = Color.floatToByte(color.red);
finalColors[colorIndex++] = Color.floatToByte(color.green);
finalColors[colorIndex++] = Color.floatToByte(color.blue);
finalColors[colorIndex++] = Color.floatToByte(color.alpha);
}
}
}
var attributes = new GeometryAttributes();
attributes.position = new GeometryAttribute({
componentDatatype : ComponentDatatype.DOUBLE,
componentsPerAttribute : 3,
values : finalPositions
});
attributes.prevPosition = new GeometryAttribute({
componentDatatype : ComponentDatatype.DOUBLE,
componentsPerAttribute : 3,
values : prevPositions
});
attributes.nextPosition = new GeometryAttribute({
componentDatatype : ComponentDatatype.DOUBLE,
componentsPerAttribute : 3,
values : nextPositions
});
attributes.expandAndWidth = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 2,
values : expandAndWidth
});
if (vertexFormat.st) {
attributes.st = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 2,
values : st
});
}
if (defined(finalColors)) {
attributes.color = new GeometryAttribute({
componentDatatype : ComponentDatatype.UNSIGNED_BYTE,
componentsPerAttribute : 4,
values : finalColors,
normalize : true
});
}
var indices = IndexDatatype.createTypedArray(size, positionsLength * 6 - 6);
var index = 0;
var indicesIndex = 0;
var length = positionsLength - 1.0;
for (j = 0; j < length; ++j) {
indices[indicesIndex++] = index;
indices[indicesIndex++] = index + 2;
indices[indicesIndex++] = index + 1;
indices[indicesIndex++] = index + 1;
indices[indicesIndex++] = index + 2;
indices[indicesIndex++] = index + 3;
index += 4;
}
return new Geometry({
attributes : attributes,
indices : indices,
primitiveType : PrimitiveType.TRIANGLES,
boundingSphere : BoundingSphere.fromPoints(positions),
geometryType : GeometryType.POLYLINES
});
};
return PolylineGeometry;
});
/*global define*/
define('Workers/createPolylineGeometry',[
'../Core/defined',
'../Core/Ellipsoid',
'../Core/PolylineGeometry'
], function(
defined,
Ellipsoid,
PolylineGeometry) {
'use strict';
function createPolylineGeometry(polylineGeometry, offset) {
if (defined(offset)) {
polylineGeometry = PolylineGeometry.unpack(polylineGeometry, offset);
}
polylineGeometry._ellipsoid = Ellipsoid.clone(polylineGeometry._ellipsoid);
return PolylineGeometry.createGeometry(polylineGeometry);
}
return createPolylineGeometry;
});
}()); | coderFirework/app | js/Cesium-Tiles/Build/CesiumUnminified/Workers/createPolylineGeometry.js | JavaScript | mit | 670,171 |
(function () {
"use strict";
WinJS.UI.Pages.define("./demos/corefeatures/arguments/arguments.html", {
ready: function (element, options) {
var sampledata = {
someLongText: "Lorem ipsum dolor sit amet, consectetur adipiscing elit fusce vel sapien elit in malesuada semper mi, id sollicitudin urna fermentum ut fusce varius nisl ac ipsum gravida vel pretium tellus."
}
WinJS.Binding.processAll(element, sampledata);
},
});
})();
| gleborgne/winjscontrib | Sources/Samples/ShowcaseApp/MCNEXT WinJS Contrib.Shared/demos/corefeatures/arguments/arguments.js | JavaScript | mit | 512 |
/**
* This file is provided by Facebook for testing and evaluation purposes
* only. Facebook reserves all rights not expressly granted.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* FACEBOOK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
import React from 'react';
import ReactDOM from 'react-dom';
import Relay from 'react-relay';
import MessageComposer from './MessageComposer';
import MessageListItem from './MessageListItem';
class MessageSection extends React.Component {
render() {
const {thread, viewer} = this.props;
var messageListItems = thread.messages.edges.map(edge => {
return (
<MessageListItem
key={edge.node.id}
message={edge.node}
/>
);
});
return (
<div className="message-section">
<h3 className="message-thread-heading">{thread.name}</h3>
<ul className="message-list" ref="messageList">
{messageListItems}
</ul>
<MessageComposer thread={thread} viewer={viewer}/>
</div>
);
}
componentDidUpdate() {
this._scrollToBottom();
}
_scrollToBottom() {
var ul = ReactDOM.findDOMNode(this.refs.messageList);
ul.scrollTop = ul.scrollHeight;
}
}
// if you wanna see how to do pagination in MessageSection,
// you can checkout add-pagination branch
// 如果你想看怎麼做 pagination, 可以 checkout add-pagination 這個分支
export default Relay.createContainer(MessageSection, {
fragments: {
thread: () => Relay.QL`
fragment on Thread {
name
messages(first: 9007199254740991) {
edges {
node {
id,
${MessageListItem.getFragment('message')}
}
}
}
${MessageComposer.getFragment('thread')}
}
`,
viewer: () => Relay.QL`
fragment on User {
${MessageComposer.getFragment('viewer')}
}
`
}
});
| chentsulin/relay-chat | js/components/MessageSection.js | JavaScript | mit | 2,272 |
bridges.factory('d3Service', ['$document', '$q', '$rootScope', function($document, $q, $rootScope) {
var d = $q.defer();
function onScriptLoad() {
$rootScope.$apply(function() { d.resolve(window.d3); });
}
var scriptTag = $document[0].createElement('script');
scriptTag.type = 'text/javascript';
scriptTag.async = true;
scriptTag.src = '/components/d3/d3.min.js';
scriptTag.onreadstatechange = function() {
if (this.readState == 'complete') {
onScriptLoad();
}
}
scriptTag.onload = onScriptLoad;
$document.find('body').append(scriptTag);
return {
d3: function() { return d.promise; }
}
}]); | RichardVSaasbook/ITCS4155Team4 | public/js/angular/factories/d3service.js | JavaScript | mit | 617 |
module.exports = () =>
console.error(
"deprecated, use require('uiks/reaks-material/multilineTextInput') instead"
)
| KAESapps/uiks | reaks-material/textArea.js | JavaScript | mit | 124 |
'use strict';
/**
*
* @param {Array} input
* @param {Object} map
* @returns {Array}
*/
function getFlattenedInterface(input, map) {
var interfaceMethods = [];
var length = input.length;
var item;
while (length--) {
item = input[length];
// items are either strings or arrays
if ('string' == typeof item) {
if (map.hasOwnProperty(item)) {
throw new Error('Duplicate interface method: ' + item);
}
interfaceMethods[(map[item] = interfaceMethods.length)] = item;
} else {
interfaceMethods = interfaceMethods.concat(
getFlattenedInterface(item, map)
);
}
}
return interfaceMethods;
}
function resolve(resolver, composition) {
var resolverMethod;
var resolverItem;
for (resolverMethod in resolver) {
if (resolver.hasOwnProperty(resolverMethod)) {
if (composition.hasOwnProperty(resolverMethod)) {
throw new Error(
'Resolved method conflicts with provided method: ' +
resolverMethod
);
}
if ('function' == typeof resolver[resolverMethod]) {
resolverItem = resolver[resolverMethod].prototype;
} else if (
('object' == typeof resolver[resolverMethod]) &&
resolver[resolverMethod]
) {
resolverItem = resolver[resolverMethod];
} else {
throw new Error([
'Could not resolve the host for `',
resolverMethod,
'` to an object or function'
].join(''));
}
if (!resolverItem.hasOwnProperty(resolverMethod)) {
throw new Error([
'Could not resolve method',
resolverMethod,
'in the host'
].join(' '));
}
composition[resolverMethod] = resolverItem[resolverMethod];
}
}
}
function getItem(hostItem, interfaceMethod, candidate) {
switch (typeof hostItem) {
case 'object':
if (hostItem.hasOwnProperty(interfaceMethod)) {
if (null !== candidate) {
throw new Error('conflict: ' + interfaceMethod);
}
candidate = hostItem[interfaceMethod];
}
break;
case 'function':
if (hostItem.prototype.hasOwnProperty(interfaceMethod)) {
if (null !== candidate) {
throw new Error('conflict: ' + interfaceMethod);
}
candidate = hostItem.prototype[interfaceMethod];
}
break;
}
return candidate;
}
function getCandidate(host, interfaceMethod) {
var candidate = null;
var hostLength;
if (host) {
hostLength = host.length;
while (hostLength--) {
candidate = getItem(
host[hostLength],
interfaceMethod,
candidate
);
}
}
if (null === candidate) {
throw new Error(
'Interface method not implemented: ' + interfaceMethod
);
} else if ('function' != typeof candidate) {
throw new TypeError('Not a function: ' + interfaceMethod);
}
return candidate;
}
/**
*
* @param {Object} configuration
* @param {Array} [configuration.implement]
* @param {Array} [configuration.use]
* @param {Object} [configuration.provide]
* @param {Object} [configuration.resolve]
* @returns {Function|Object}
*/
function impose(configuration) {
var composition = {};
var interfaceList;
var interfaceLength;
var interfaceMethod;
var host;
var provider;
var providerMethod;
if (configuration.hasOwnProperty('provide')) {
provider = configuration.provide;
for (providerMethod in provider) {
if (provider.hasOwnProperty(providerMethod)) {
composition[providerMethod] = provider[providerMethod];
}
}
}
if (configuration.hasOwnProperty('resolve')) {
resolve(configuration.resolve, composition);
}
if (configuration.hasOwnProperty('implement')) {
interfaceList = getFlattenedInterface(configuration.implement, {});
interfaceLength = interfaceList.length;
if (configuration.hasOwnProperty('use')) {
host = configuration.use;
}
while (interfaceLength--) {
interfaceMethod = interfaceList[interfaceLength];
if (!composition.hasOwnProperty(interfaceMethod)) {
composition[interfaceMethod] = getCandidate(
host,
interfaceMethod
);
}
}
}
if (provider && provider.hasOwnProperty('constructor')) {
provider.constructor.prototype = composition;
return provider.constructor;
}
return composition;
}
module.exports = impose;
| ebednarz/impose | index.js | JavaScript | mit | 5,057 |
import Vue from 'vue'
import App from './App'
import router from './router'
import axios from 'axios'
import 'normalize.css/normalize.css'
Vue.config.productionTip = false
// 添加响应拦截器
axios.interceptors.response.use(function (res) {
// 对响应数据做些事
return res.data
}, function (error) {
// 请求错误时做些事
return Promise.reject(error)
})
Vue.prototype.$http = axios
/* eslint-disable no-new */
new Vue({
el: '#app',
router,
render: h => h(App)
})
| longze/my-cellar | web/articles/markdown-remark/demo/demo-in-browser/src/main.js | JavaScript | mit | 499 |
'use strict';
module.exports = function (grunt) {
// show elapsed time at the end
require('time-grunt')(grunt);
// load all grunt tasks
require('load-grunt-tasks')(grunt);
// Define the configuration for all the tasks
grunt.initConfig({
// Project settings
build: {
// Configurable paths
artifact: 'all.js',
target: 'build',
source: 'src'
},
clean: {
build: {
src: [ '<%= build.target %>' ]
}
},
concat: {
dist: {
src: [ '<%= build.source %>/{,*/}*.js' ],
dest: '<%= build.target %>/<%= build.artifact %>'
}
},
// Watches files for changes and runs tasks based on the changed files
watch: {
livereload: {
options: {
livereload: '<%= connect.options.livereload %>',
open: true
},
files: [
'<%= build.source %>/{,*/}*.js',
'page/{,*/}*.html'
],
tasks: [
'build'
]
}
},
// The actual grunt server settings
connect: {
options: {
port: 9050,
livereload: 35729,
hostname: '0.0.0.0'
},
livereload: {
base: 'page'
}
},
jshint: {
options: {
jshintrc: '.jshintrc'
},
all: [
'Gruntfile.js',
'<%= build.source %>/{,*/}*.js'
]
}
});
grunt.registerTask('serve', function (target) {
grunt.task.run([
'build',
'connect:livereload',
'watch'
]);
});
grunt.registerTask('build', [
'concat'
]);
grunt.registerTask('default', [
'jshint',
'build'
]);
};
| dtsimbal/celica | Gruntfile.js | JavaScript | mit | 2,057 |
describe('Places', function() {
it('getPlace', function(done){
FS.getPlace('https://familysearch.org/platform/places/2557657').then(function(response) {
expect(response.getPlace().getId()).toBe('2557657');
expect(response.getPlace().getNames()[0].getValue()).toBe('Nohabuna Island');
expect(response.getPlace().getNames()[0].getLang()).toBe('en');
done();
});
});
it('getPlaceDescription', function(done){
FS.getPlaceDescription('https://familysearch.org/platform/places/description/50615').then(function(response){
var place = response.getPlaceDescription(),
jurisdiction = place.getJurisdictionSummary();
expect(place.getId()).toBe('50615');
expect(place.getLang()).toBe('en');
expect(place.getIdentifiers()['http://gedcomx.org/Primary'][0]).toBe('https://familysearch.org/platform/places/2557657');
expect(place.getNames()[0].getLang()).toBe('en');
expect(place.getNames()[0].getValue()).toBe('Nohabuna Island');
expect(place.getTypeUri()).toBe('https://familysearch.org/platform/places/types/56');
expect(place.getLatitude()).toBe(-7.35);
expect(place.getLongitude()).toBe(158.0666667);
expect(place.getName()).toBe('Nohabuna Island');
expect(place.getFullName()).toBe('Nohabuna Island, Solomon Islands');
expect(place.getType()).toBe('Island');
expect(jurisdiction.getId()).toBe('213');
expect(jurisdiction.getNames()[0].getValue()).toBe('Solomon Islands');
place.getJurisdictionDetails().then(function(response){
var place = response.getPlaceDescription();
expect(place.getName()).toBe('Solomon Islands');
expect(place.getFullName()).toBe('Solomon Islands');
expect(place.getType()).toBe('Commonwealth Nation');
// Verify that the promise fails when no jurisdiction is available
place.getJurisdictionDetails().then(null, function(){
done();
});
});
});
});
it('getPlacesSearch', function(done){
FS.getPlacesSearch({
name: 'Paris',
'+parentId': '442102'
}).then(function(response){
var results = response.getSearchResults();
expect(results.length).toBe(2);
var firstResult = results[0],
firstPlace = firstResult.getPlace(),
secondResult = results[1],
secondPlace = secondResult.getPlace();
expect(firstResult.getId()).toBe('7344697');
expect(firstPlace.getId()).toBe('7344697');
expect(firstPlace.getFullName()).toBe('Paris, Ville-de-Paris, District of the Paris Region, France');
expect(firstPlace.getType()).toBe('Populated Place');
expect(secondResult.getId()).toBe('5953651');
expect(secondPlace.getId()).toBe('5953651');
expect(secondPlace.getFullName()).toBe('Paris, Ville-de-Paris, District of the Paris Region, France');
expect(secondPlace.getType()).toBe('District');
done();
});
});
it('getPlaceDescriptionChildren', function(done){
FS.getPlaceDescriptionChildren('https://familysearch.org/platform/places/description/1054/children').then(function(response){
var children = response.getChildren();
expect(children.length).toBe(6);
expect(children[0].getId()).toBe('432379');
expect(children[0].getNames()[2].getValue()).toBe('榛原郡');
done();
});
});
it('getPlaceType', function(done){
FS.getPlaceType(103).then(function(response){
var type = response.getPlaceType();
expect(type.getId()).toBe('103');
expect(type.getLabel()).toBe('Recreation Area');
expect(type.getDescription()).toBe('A recreation area; amphitheater, athletic track or field, racetrack, golf course, fishing area, etc.');
done();
});
});
it('getPlaceTypes', function(done){
FS.getPlaceTypes().then(function(response){
var list = response.getList(),
types = response.getPlaceTypes(),
type = types[0];
expect(list.getTitle()).toBe('Place Types');
expect(list.getDescription()).toBe('List of available place types.');
expect(types.length).toBe(5);
expect(type.getId()).toBe('143');
expect(type.getLabel()).toBe('Aboriginal Council');
expect(type.getDescription()).toBe('A political jurisdiction in countries with native populations such as Australia.');
done();
}).catch(function(e){
console.error(e.stack);
});
});
it('getPlaceTypeGroup', function(done){
FS.getPlaceTypeGroup(26).then(function(response){
var list = response.getList(),
types = response.getPlaceTypes(),
type = types[0];
expect(list.getTitle()).toBe('Country-Like');
expect(list.getDescription()).toBe('Countries and highest level administrative places (ADM0)');
expect(types.length).toBe(18);
expect(type.getId()).toBe('343');
expect(type.getLabel()).toBe('Republic');
expect(type.getDescription()).toBe('A country whose government is a representative democracy in which the people\'s elected deputies (representatives), not the people themselves, vote on legislation.');
done();
});
});
it('getPlaceTypeGroups', function(done){
FS.getPlaceTypeGroups().then(function(response){
var list = response.getList(),
groups = response.getPlaceTypeGroups(),
group = groups[0];
expect(list.getTitle()).toBe('Place Type Groups');
expect(list.getDescription()).toBe('List of available place type groups.');
expect(groups.length).toBe(18);
expect(group.getId()).toBe('4');
expect(group.getLabel()).toBe('Geographic (Continents)');
expect(group.getDescription()).toBe('Geographic feature type');
done();
});
});
}); | FamilySearch/familysearch-javascript-sdk | test/unit/placesSpec.js | JavaScript | mit | 5,811 |
'use strict';
/**
* Module dependencies.
*/
var mongoose = require('mongoose'),
errorHandler = require('./errors.server.controller'),
Article = mongoose.model('Article'),
_ = require('lodash');
/**
* Create a article
*/
exports.create = function(req, res) {
var article = new Article(req.body);
article.user = req.user;
article.save(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.json(article);
}
});
};
/**
* Show the current article
*/
exports.read = function(req, res) {
res.json(req.article);
};
/**
* Update a article
*/
exports.update = function(req, res) {
var article = req.article;
//console.log('resetting parent');
//article.parent = '';//article.id;
article = _.extend(article, req.body);
article.save(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.json(article);
}
});
};
exports.kismet = function(req, res) {
console.log('articles.server.controller.kismet: sending kismet to: ' + req.article._id);
var conditions = { _id: req.article._id };
var update = { $inc: { kismet: 1 }};
Article.update(conditions, update, function(err, article) {
if (err) {
console.log('articles.server.controller.kismet: findbyId ERROR: ' + err);
return res.status(400).send({ message: errorHandler.getErrorMessage(err) });
} else if (!article) {
console.log('articles.server.controller.kismet: ERROR: no article found for id: ' + req.article._id);
return res.status(400).send(new Error('Article does not exist: ' + req.article._id));
} else {
res.status(200).send();
}
});
};
/**
* Delete an article
*/
exports.delete = function(req, res) {
var article = req.article;
article.remove(function(err) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.json(article);
}
});
};
/**
* List of Articles
*/
exports.list = function(req, res) {
var sortBy = req.query.sortBy;
Article.find({parent:'top'}).sort(sortBy).populate('user', 'username').exec(function(err, articles) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.json(articles);
}
});
};
exports.listComments = function(req, res) {
// console.log('list:');
// console.log(JSON.stringify(req.query));
Article.find({parent:req.param('parentId')}).sort('-created').populate('user', 'username').exec(function(err, articles) {
if (err) {
return res.status(400).send({
message: errorHandler.getErrorMessage(err)
});
} else {
res.json(articles);
}
});
};
/**
* Article middleware
*/
exports.articleByID = function(req, res, next, id) {
Article.findById(id).populate('user', 'username').exec(function(err, article) {
if (err) return next(err);
if (!article) return next(new Error('Failed to load article ' + id));
req.article = article;
next();
});
};
exports.articleByParent = function(req, res, next, id) {
Article.where('parent').equals(id).populate('user', 'username').exec(function(err, article) {
if (err) return next(err);
if (!article) return next(new Error('Failed to load article ' + id));
req.article = article;
next();
});
};
/**
* Article authorization middleware
*/
exports.hasAuthorization = function(req, res, next) {
if (req.article.user.id !== req.user.id) {
return res.status(403).send({
message: 'User is not authorized'
});
}
next();
};
| danmedani/cafeCholoma | app/controllers/articles.server.controller.js | JavaScript | mit | 3,550 |
function HTMLActuator() {
this.tileContainer = document.querySelector(".tile-container");
this.scoreContainer = document.querySelector(".score-container");
this.bestContainer = document.querySelector(".best-container");
this.messageContainer = document.querySelector(".game-message");
this.sharingContainer = document.querySelector(".score-sharing");
this.score = 0;
}
HTMLActuator.prototype.actuate = function (grid, metadata) {
var self = this;
window.requestAnimationFrame(function () {
self.clearContainer(self.tileContainer);
grid.cells.forEach(function (column) {
column.forEach(function (cell) {
if (cell) {
self.addTile(cell);
}
});
});
self.updateScore(metadata.score);
self.updateBestScore(metadata.bestScore);
if (metadata.terminated) {
if (metadata.over) {
self.message(false); // You lose
} else if (metadata.won) {
self.message(true); // You win!
}
}
});
};
// Continues the game (both restart and keep playing)
HTMLActuator.prototype.continue = function () {
if (typeof ga !== "undefined") {
ga("send", "event", "game", "restart");
}
this.clearMessage();
};
HTMLActuator.prototype.clearContainer = function (container) {
while (container.firstChild) {
container.removeChild(container.firstChild);
}
};
HTMLActuator.prototype.addTile = function (tile) {
var self = this;
var wrapper = document.createElement("div");
var inner = document.createElement("div");
var position = tile.previousPosition || { x: tile.x, y: tile.y };
var positionClass = this.positionClass(position);
// We can't use classlist because it somehow glitches when replacing classes
var classes = ["tile", "tile-" + tile.value, positionClass];
if (tile.value > 2048) classes.push("tile-super");
this.applyClasses(wrapper, classes);
inner.classList.add("tile-inner");
inner.textContent = tile.value;
if (tile.previousPosition) {
// Make sure that the tile gets rendered in the previous position first
window.requestAnimationFrame(function () {
classes[2] = self.positionClass({ x: tile.x, y: tile.y });
self.applyClasses(wrapper, classes); // Update the position
});
} else if (tile.mergedFrom) {
classes.push("tile-merged");
this.applyClasses(wrapper, classes);
// Render the tiles that merged
tile.mergedFrom.forEach(function (merged) {
self.addTile(merged);
});
} else {
classes.push("tile-new");
this.applyClasses(wrapper, classes);
}
// Add the inner part of the tile to the wrapper
wrapper.appendChild(inner);
// Put the tile on the board
this.tileContainer.appendChild(wrapper);
};
HTMLActuator.prototype.applyClasses = function (element, classes) {
element.setAttribute("class", classes.join(" "));
};
HTMLActuator.prototype.normalizePosition = function (position) {
return { x: position.x + 1, y: position.y + 1 };
};
HTMLActuator.prototype.positionClass = function (position) {
position = this.normalizePosition(position);
return "tile-position-" + position.x + "-" + position.y;
};
HTMLActuator.prototype.updateScore = function (score) {
this.clearContainer(this.scoreContainer);
var difference = score - this.score;
this.score = score;
this.scoreContainer.textContent = this.score;
if (difference > 0) {
var addition = document.createElement("div");
addition.classList.add("score-addition");
addition.textContent = "+" + difference;
this.scoreContainer.appendChild(addition);
}
};
HTMLActuator.prototype.updateBestScore = function (bestScore) {
this.bestContainer.textContent = bestScore;
};
HTMLActuator.prototype.message = function (won) {
var type = won ? "game-won" : "game-over";
var message = won ? "You win! ⊂（＿＾ω＾）⊃" : "Game over!";
if (typeof ga !== "undefined") {
ga("send", "event", "game", "end", type, this.score);
}
this.messageContainer.classList.add(type);
this.messageContainer.getElementsByTagName("p")[0].textContent = message;
this.clearContainer(this.sharingContainer);
this.sharingContainer.appendChild(this.scoreTweetButton());
twttr.widgets.load();
};
HTMLActuator.prototype.clearMessage = function () {
// IE only takes one value to remove at a time.
this.messageContainer.classList.remove("game-won");
this.messageContainer.classList.remove("game-over");
};
HTMLActuator.prototype.scoreTweetButton = function () {
var tweet = document.createElement("a");
tweet.classList.add("twitter-share-button");
tweet.setAttribute("href", "https://twitter.com/share");
tweet.setAttribute("data-via", "shiraihii");
tweet.setAttribute("data-url", "http://2048bkb.sinaapp.com/");
tweet.setAttribute("data-counturl", "http://2048bkb.sinaapp.com/");
tweet.textContent = "Tweet";
var text = "I scored " + this.score + " points at 兵庫北 2048, a game where you " +
"join 兵庫北 to score high! #兵庫北2048";
tweet.setAttribute("data-text", text);
return tweet;
};
| shiraihii/2048-bkb | js/html_actuator.js | JavaScript | mit | 5,074 |
initSidebarItems({"mod":[["keysyms",""]],"struct":[["KbState",""],["MappedKeyboard","A wayland keyboard mapped to its keymap"]]}); | mcanders/bevy | doc/wayland_kbd/sidebar-items.js | JavaScript | mit | 130 |
/*!
* Copyright(c) 2014 Jan Guth <git@pan.st>
* MIT Licensed
*/
/**
* Module dependencies.
*/
var utils = require('./utils'),
path = require('path'),
fs = require('fs'),
linker = require('./linker'),
tmp = require('./temporary'),
browserify = require('browserify'),
greact = require('grunt-react');
//TODO: clean up this method! make it pretty...
module.exports = function(html, _options, fn) {
var errors = null,
sails = _options.sails,
_ = _options._,
b = browserify(),
options = _.merge(require('./options'), sails.config.sailsReact || {}),
templateFolder = path.join(sails.config.rootPath, options.templates);
if ( options.temporary.folder === true )
// if true use standard template folder for temp files
options.temporary.folder = templateFolder;
// check cache
options.cache._isCached = false;
if ( options.cache.enabled ) {
options.cache._relFile = utils.placeholder(options.cache.dest, {url: _options.req.url.replace(/[^a-z0-9_\-\.]/ig, '_'), lang: _options.locale});
options.cache._file = path.join(sails.config.paths.public, options.cache._relFile);
utils.slog('Check cache file: [' + options.cache._file + ']');
// ceck if cache was already created
if ( fs.existsSync(options.cache._file) ) {
options.cache._isCached = true;
}
}
// check if it is necessary to parse html
if ( ! options.cache._isCached || options.render.autoUseTag ) {
var tagNumber = 0;
html = html.replace(new RegExp('<\s*([a-z0-9_-]+)[^<]+?(sails-react(:?="([^"]+?)")?)[^>]*?>', 'ig'), function(match, tag, sailsReact, specific, offset, string) {
var lookup = (specific || tag),
// escape for regex
sailsReactTag = new RegExp(utils.regex(sailsReact), ''),
reactScript = "\n",
tempName = "sails-react_tag_" + tagNumber++;
// no need to process all this if file is already cached.
if ( ! options.cache._isCached ) {
if ( options.render.lowerCaseFilenames )
lookup = lookup.toLowerCase();
var file = path.join(templateFolder, utils.placeholder(options.render.filePattern, {path: lookup, lang: _options.locale})),
tempFile = null;
// Only continue if file exists
if ( fs.existsSync(file) ) {
utils.slog('Process file: [' + file + ']');
// create temp id + file
try {
tempFile = tmp.createFileSync(fs.readFileSync(file), options.temporary);
}
catch(err) { utils.slog('Could not write to temp file.' + err.toString(), 'warn'); return fn(null, html); }
if ( options.render.processView ) {
// lets run registered view engine
sails.config.views.engine.fn(tempFile, _options, function(err, view) {
if ( ! err ) {
fs.writeFileSync(tempFile, view);
}
else {
// disable caching
options.cache.enabled = false;
utils.slog('View engine (' + sails.config.views.engine.ext + ') throws error: ' + err.toString(), 'warn');
}
});
}
if ( options.render.autoUseTag ) {
var rComponent = "\n",
// remove sails-react attribute
cleanMatch = match.replace(sailsReactTag, '');
rComponent += "React.renderComponent(" +
cleanMatch + ", " +
(typeof options.render.autoUseTag == 'string' ? "document.getElementById('" + tempName + "')" : options.render.querySelector + "('" + tag + "[sails-react=\"" + tempName + "\"]')") +
");";
fs.appendFileSync(tempFile, rComponent);
}
// add file to browserify
b.add(tempFile);
// save file name for cleanup later on
if ( options.temporary.cleanup ) {
options.temporary._cleanup = options.temporary._cleanup || [];
options.temporary._cleanup[options.temporary._cleanup.length] = tempFile;
}
}
else {
utils.slog('There is no such file: [' + file + ']', 'warn');
}
}
var replacementTag = match;
if ( typeof options.render.autoUseTag == 'string' )
replacementTag = '<' + options.render.autoUseTag + ' id="' + tempName + '" />';
else if ( options.render.autoUseTag )
replacementTag = match.replace(sailsReactTag, 'sails-react="' + tempName + '"');
else
replacementTag = match.replace(sailsReactTag, '');
return replacementTag;
});
}
if ( options.cache._isCached ) {
utils.slog('Using cached file.');
if ( options.linker.linkCacheFile ) {
// only link cached file
html = linker.insert(options.cache._relFile, html, options);
fn(null, html);
}
else {
// insert source of cached file
fs.createReadStream(options.cache._file).pipe(linker.stream(html, options, fn));
}
}
else {
// process data
if ( options.render.processJsx ) {
// let compile jsx to js
b.transform(greact.browserify);
}
// process files
try {
b.bundle().pipe(linker.stream(html, options, fn));
}
catch ( err ) {
// disable caching
options.cache.enabled = false;
utils.slog('Browserify throws error: ' + err.toString(), 'warn');
}
}
};
| pan-st/sails-react | lib/render.js | JavaScript | mit | 5,440 |
/* eslint-enable describe it sinon */
import React from 'react';
import expect from 'expect';
import Grid from './../../src/components/Grid.jsx';
import { mountWithContext } from './../testUtils';
const props = {
data: [],
columns: [
{
name: 'Player',
dataIndex: 'name',
sortable: true
},
{
name: 'Position',
dataIndex: 'position'
}
],
stateKey: 'empty-grid',
emptyDataMessage: 'Aint no data here',
plugins: {}
};
describe('Empty data row', () => {
const wrapper = mountWithContext(<Grid { ...props } />);
it('Should render a message based on props', (done) => {
setTimeout(() => {
const emptyRow = wrapper.find('.react-grid-empty-row');
expect(
emptyRow.html()
).toContain('Aint no data here');
done();
}, 200);
});
});
| bencripps/react-redux-grid | test/integration/empty-data.test.js | JavaScript | mit | 940 |
'use strict';
const fs = require('fs');
module.exports = function(filename, data) {
return new Promise(function(res, rej) {
fs.writeFile(filename, data, function(err) {
if ( err ) {
rej(err);
}
res();
});
});
};
| xing-zhi/jade-reference | gulp-tasks/lib/write-file.js | JavaScript | mit | 253 |
/**
* createTreeWalker()
* Creates a TreeWalker that filters a subtree of the DOM.
*
* createTreeWalker(root, whatToShow, [acceptNode], [expandEntityReferences])
*
* Parameters:
* root
* DOM node, root of subtree to be walked
*
* whatToShow
* node types that should be returned by the TreeWalker, OR'ed together:
* NodeFilter.SHOW_ELEMENT
* NodeFilter.SHOW_TEXT
* NodeFilter.SHOW_ATTRIBUTE
* NodeFilter.SHOW_COMMENT
* NodeFilter.SHOW_ALL (for all DOM nodes)
*
* acceptNode
* optional user-defined filter function of type
* DOMNode -> oneof(NodeFilter.FILTER_ACCEPT, NodeFilter.FILTER_SKIP, NodeFilter.FILTER_REJECT)
* Nodes that pass the whatToShow filter are passed to this acceptNode function.
* acceptNode may return one of three values:
* FILTER_ACCEPT to make the TreeWalker return the node
* FILTER_SKIP to make TreeWalker skip the node, but still consider its children
* FILTER_REJECT to make TreeWalker skip the node AND all its descendents
* expandEntityReferences
* optional boolean flag, not used in HTML
*
*/
/**********************************************
* Examples of createTreeWalker
*
// get all text nodes inside first link in document
var walker = createTreeWalker(document.links[0], NodeFilter.SHOW_TEXT);
// find all images in document
var walker = createTreeWalker
(document,
NodeFilter.SHOW_ELEMENT,
function(node) {
return (node.tagName=="img")
? NodeFilter.FILTER_ACCEPT
: NodeFilter.FILTER_SKIP;
});
************************************************
* Patterns for iterating over the resulting TreeWalker:
*
// Process nodes in filtered subtree
// (EXCLUDING the subtree root):
while ((node = walker.nextNode()) != null) {
... use node here
}
// Same as above, but avoids a temp variable:
while (walker.nextNode()) {
... use walker.currentNode here
}
// Process the root of the subtree
// as well as its descendents:
// (This includes the root node even if it does not satisfy the filter.)
do {
... use walker.currentNode here
} while (walker.nextNode());
// Process the filtered tree recursively:
function recursive_algorithm(walker) {
... use walker.currentNode here if you want to
process the root of the subtree + descendents
if (walker.firstChild()) {
do {
... use walker.currentNode here to skip the root
and handle only the filtered descendents
recursive_algorithm(walker);
} while (tw.nextSibling());
tw.parentNode();
}
}
* See http://www.mozilla.org/docs/dom/samples/treewalkerdemo.xml
* for more examples of using TreeWalker recursively
*********************************************/
// createTreeWalker works around a bug in Firefox.
//
// When the whatToShow filter fails to match any of the descendents of the root,
// Firefox's TreeWalker returns nodes *after* the root (outside the
// root's subtree), instead of simply returning no nodes at all.
//
// We work around this bug by wrapping the TreeWalker with a wrapper that checks
// the first valid node returned (by any of TreeWalker's methods) to make sure it's
// in the root's subtree. If it is, then we don't have to check any of the other
// nodes returned by the TreeWalker, so we pay for this check only on the first node.
// If it isn't, then we return null (no nodes).
//
function createTreeWalker(node, whatToShow, acceptNode, expandEntityReferences) {
// acceptNode and expandEntityReferences are optional
if (acceptNode === undefined) {
acceptNode = null;
}
if (expandEntityReferences === undefined) {
expandEntityReferences = false;
}
if (instanceOf(node, Document)) {
node = node.documentElement;
}
var doc = node.ownerDocument;
var walker = doc.createTreeWalker(node, whatToShow, acceptNode, expandEntityReferences);
var wrapper = new TreeWalkerWrapper(walker);
return wrapper;
}
function TreeWalkerWrapper(walker) {
this.walker = walker;
this.root = walker.root;
this.whatToShow = walker.whatToShow;
this.acceptNode = walker.acceptNode;
this.expandEntityReferences = walker.expandEntityReferences;
this.currentNode = walker.currentNode;
this.alreadyChecked = false;
}
TreeWalkerWrapper.prototype.check = function(node) {
if (!node) {
//debug("check: node is null");
return node;
} else if (this.alreadyChecked) {
//debug("check: already safe");
return (this.currentNode = node);
} else if (!this.isAncestorOf(this.root, node)) {
//debug("check: caught bug, returning null");
return null;
} else {
//debug("check: checked ancestry, safe");
this.alreadyChecked = true;
return (this.currentNode = node);
}
}
TreeWalkerWrapper.prototype.isAncestorOf = function(ancestor, node) {
while (node) {
if (node === ancestor) {
return true;
} else {
node = node.parentNode;
}
}
return false;
}
TreeWalkerWrapper.prototype.firstChild = function() {
return this.check(this.walker.firstChild());
}
TreeWalkerWrapper.prototype.lastChild = function() {
return this.check(this.walker.lastChild());
}
TreeWalkerWrapper.prototype.nextNode = function() {
return this.check(this.walker.nextNode());
}
TreeWalkerWrapper.prototype.nextSibling = function() {
return this.check(this.walker.nextSibling());
}
TreeWalkerWrapper.prototype.parentNode = function() {
return this.check(this.walker.parentNode());
}
TreeWalkerWrapper.prototype.previousNode = function() {
return this.check(this.walker.previousNode());
}
TreeWalkerWrapper.prototype.previousSibling = function() {
return this.check(this.walker.previousSibling());
}
//
// Tests.
//
/*
// Run this test on a page whose first link is simple text.
var link = document.links[0];
var walker = createTreeWalker(link, NodeFilter.SHOW_ELEMENT);
var node = walker.nextNode();
if (node != null && node.parentNode !== link) {
alert("Test failed: TreeWalker returned an element outside the root's subtree");
}
*/
| bolinfest/chickenfoot | src/core/dom/treeWalker.js | JavaScript | mit | 6,203 |
var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var multer = require('multer');
var autoReap = require('multer-autoreap');
var routes = require('./routes/index');
var app = express();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'hbs');
app.set('view options', { layout: false });
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: '/tmp/' }).any());
app.use(autoReap);
app.use(cookieParser());
app.use('/vendor', express.static(path.join(__dirname, 'node_modules')));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', routes);
// Forward 404 to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
// Error handler
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err // Use `{}` to hide stacktraces
});
});
module.exports = app;
| flyweb/retropie-flyweb | app.js | JavaScript | mit | 1,330 |
'use strict';
import models from '../../models';
import Boom from 'boom';
// Product Route Configs
let userAchievements = {
create: (request, reply) => {
models.User.find({
'where': {
'id': request.payload.UserId
}
})
.then((user) => {
models.Achievement.find({
'where': {
'$or': [
{
'id': request.payload.AchievementId
},
{
'title': request.payload.AchievementTitle
},
]
}
})
.then((achievement) => {
if (achievement) {
user.addUserAchievement(achievement).then((userHasAchievements) => {
if (request.payload.notify) {
models.UserNotification.create({
'UserId': request.payload.UserId,
'type': 'newAchievement',
'fromUsername': 'systemAdmin',
'details': request.payload.AchievementTitle
}).then(() => {
reply(userHasAchievements).code(200);
});
} else {
reply(userHasAchievements).code(200);
}
});
} else {
reply(Boom.notFound('No achievement found with the supplied id or title'));
}
});
});
},
createAndNotify: (request, reply) => {
models.User.find({
'where': {
'id': request.payload.UserId
}
})
.then((user) => {
models.Achievement.find({
'where': {
'$or': [
{
'id': request.payload.AchievementId
},
{
'title': request.payload.AchievementTitle
},
]
}
})
.then((achievement) => {
if (achievement) {
user.addUserAchievement(achievement).then((userHasAchievements) => {
reply(userHasAchievements).code(200);
});
} else {
reply(Boom.notFound('No achievement found with the supplied id or title'));
}
});
});
},
remove: (request, reply) => {
models.User.find({
'where': {
'id': request.params.UserId
}
})
.then((user) => {
models.Achievement.find({
'where': {
'id': request.params.AchievementId
},
})
.then((achievement) => {
if (achievement) {
user.removeUserAchievement(achievement).then((user) => {
reply(user).code(200);
});
} else {
reply(Boom.notFound('No achievement found with the supplied id or title'));
}
});
});
},
'search': (request, reply) => {
let pageSize = parseInt(request.payload.pageSize, 10) || 20;
let offset = (request.payload.pageNumber - 1) * pageSize;
models.User.find({
'where': {
'username': request.payload.username
},
'include': [{
'model': models.Achievement
}]
}).then((user) => {
user = user.get({
'plain': true
});
let results = user.Achievements;
let totalPages = Math.ceil(results.length === 0 ? 1 : (results.length / pageSize));
reply({
'pagination': {
'pageNumber': request.payload.pageNumber,
'pageSize': pageSize,
'totalPages': totalPages,
'totalResults': results.length
},
'results': user.Achievements.splice(offset, offset + pageSize)
}).code(200);
});
}
};
export default userAchievements;
| zdizzle6717/battle-comm | server/routes/handlers/userAchievements.js | JavaScript | mit | 3,202 |
module.exports = {
components: ['form']
}
| dennisreimann/uiengine | test/project/uiengine/pages/patterns/organisms/page.config.js | JavaScript | mit | 44 |
var _Object = require("./object");
var Evented = _Object.clone(function () {
this.extended = function (extendee) {
extendee.handlers = {};
};
this.on = function (event, action) {
if (!this.handlers[event])
this.handlers[event] = [];
this.handlers[event].push(action);
};
this.trigger = function (event) {
var args = Array.prototype.slice.call(arguments, 1);
var self = this;
if (this.handlers[event])
this.handlers[event].reverse().forEach(function (action) {
action.apply(self, args);
});
};
});
module.exports = Evented; | pmh/elf | lib/runtime/evented.js | JavaScript | mit | 590 |
$(function () {
// Create the chart
$('#air-quality-pm25-chart').highcharts({
title: {
text: "Air Quality (Particulate Matter)"
},
data: {
googleSpreadsheetKey: '1wuVwW1LheXoul799yVHJB7cnXCrr3asom7HAGCowIVs'
},
yAxis: {
title: {
text: 'micrograms per cubic meter'
},
plotLines: [{
value: 12,
color: 'green',
dashStyle: 'ShortDot',
width: 2,
label: {
text: 'California Standard'
}}],
min: 0
},
tooltip: {
valuePrefix: ''
},
credits: {
enabled: false
}
});
});
| code4sac/sac2050 | charts/sustainability/air-quality-pm25.js | JavaScript | mit | 762 |
/**
* Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
* under one or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information regarding copyright
* ownership.
*
* Camunda licenses this file to you under the MIT; you may not use this file
* except in compliance with the MIT License.
*/
'use strict';
var Clipboard = require('diagram-js/lib/features/clipboard/Clipboard').default;
module.exports = {
clipboard: [ 'value', new Clipboard() ]
};
| camunda/bpmn-io-modeler | client/src/app/tabs/bpmn/modeler/features/global-clipboard/index.js | JavaScript | mit | 536 |
var page = require("webpage").create();
page.open("http://example.com", function() {
page.render("example.png");
phantom.exit();
});
| voidrank/phantomjs-practice | save-html-to-png/main.js | JavaScript | mit | 141 |
import React from 'react'
import env from '~base/env-variables'
const Image = (props) => {
var src = props.src
if (env.PREFIX) {
src = env.PREFIX + src
}
return <img {...props} src={src} />
}
export default Image
| latteware/marble-seed | lib/frontend/components/image.js | JavaScript | mit | 228 |
'use strict';
/* Controllers */
var videoControllers = angular.module('videoControllers', []);
videoControllers.controller('categoryListCtrl', ['$scope', '$http','$routeParams',
function($scope, $http,$routeParams) {
$http.get('http://localhost:8080/ws/category/'+$routeParams.category).success(function(data) {
$scope.videos = data;
});
$scope.orderProp = 'title';
}]);
| hbakir/educatech | src/main/resources/static/js/controllers.js | JavaScript | mit | 397 |
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
// @inheritedComponent CSSTransition
import React from 'react';
import CSSTransition from 'react-transition-group/CSSTransition';
import withTheme from '../styles/withTheme';
// Only exported for tests.
export function getScale(value) {
return `scale(${value}, ${Math.pow(value, 2)})`;
}
/**
* The Grow transition is used by the Popover component.
* It's using [react-transition-group](https://github.com/reactjs/react-transition-group) internally.
*/
class Grow extends React.Component {
constructor(...args) {
var _temp;
return _temp = super(...args), this.autoTimeout = undefined, this.handleEnter = node => {
node.style.opacity = '0';
node.style.transform = getScale(0.75);
if (this.props.onEnter) {
this.props.onEnter(node);
}
}, this.handleEntering = node => {
const { theme, timeout } = this.props;
let duration = 0;
if (timeout === 'auto') {
duration = theme.transitions.getAutoHeightDuration(node.clientHeight);
this.autoTimeout = duration;
} else if (typeof timeout === 'number') {
duration = timeout;
} else if (timeout && typeof timeout.enter === 'number') {
duration = timeout.enter;
} else {
// The propType will warn in this case.
}
node.style.transition = [theme.transitions.create('opacity', {
duration
}), theme.transitions.create('transform', {
duration: duration * 0.666
})].join(',');
node.style.opacity = '1';
node.style.transform = getScale(1);
if (this.props.onEntering) {
this.props.onEntering(node);
}
}, this.handleExit = node => {
const { theme, timeout } = this.props;
let duration = 0;
if (timeout === 'auto') {
duration = theme.transitions.getAutoHeightDuration(node.clientHeight);
this.autoTimeout = duration;
} else if (typeof timeout === 'number') {
duration = timeout;
} else if (timeout && typeof timeout.exit === 'number') {
duration = timeout.exit;
} else {
// The propType will warn in this case.
}
node.style.transition = [theme.transitions.create('opacity', {
duration
}), theme.transitions.create('transform', {
duration: duration * 0.666,
delay: duration * 0.333
})].join(',');
node.style.opacity = '0';
node.style.transform = getScale(0.75);
if (this.props.onExit) {
this.props.onExit(node);
}
}, this.addEndListener = (node, next) => {
if (this.props.timeout === 'auto') {
setTimeout(next, this.autoTimeout || 0);
}
}, _temp;
}
render() {
const _props = this.props,
{
appear,
children,
onEnter,
onEntering,
onExit,
rootRef,
style: styleProp,
transitionClasses,
timeout,
theme
} = _props,
other = _objectWithoutProperties(_props, ['appear', 'children', 'onEnter', 'onEntering', 'onExit', 'rootRef', 'style', 'transitionClasses', 'timeout', 'theme']);
const style = _extends({}, children.props.style, styleProp);
// For server side rendering.
if (!this.props.in || appear) {
style.opacity = '0';
}
return React.createElement(
CSSTransition,
_extends({
classNames: transitionClasses,
onEnter: this.handleEnter,
onEntering: this.handleEntering,
onExit: this.handleExit,
addEndListener: this.addEndListener,
appear: appear,
style: style,
timeout: timeout === 'auto' ? null : timeout
}, other, {
ref: rootRef
}),
children
);
}
}
Grow.defaultProps = {
appear: true,
timeout: 'auto',
transitionClasses: {}
};
export default withTheme()(Grow); | uplevel-technology/material-ui-next | es/transitions/Grow.js | JavaScript | mit | 4,299 |
/**
* @ngdoc service
* @name refigureProfile.services:profile
* @description
* profile service
*/
(function (angular) {
'use strict';
angular
.module('refigureProfile')
.factory('profile', profile);
profile.$inject = [
'$http',
'profileApiUri',
'auth'
];
function profile($http, profileApiUri, auth) {
var exports = {
getAccount: getAccount,
updateAccount: updateAccount,
updatePassword: updatePassword
};
return exports;
////////////////
/**
* @ngdocs method
* @name refigureProfile.services:profile#getAccount
* @methodOf refigureProfile.services:profile
* @returns {Object} promise
* @description
* Loads account info from session
*/
function getAccount() {
return auth.usrInfo();
}
/**
* @ngdocs method
* @name refigureProfile.services:profile#updateAccount
* @methodOf refigureProfile.services:profile
* @param {Object} data New account information
* @returns {Object} promise
* @description
* Updates account information
*/
function updateAccount(data) {
return $http
.post(profileApiUri + '/profile-update/', data)
.then(function (res) {
var data = utils.get(res, 'data.data');
auth.fillUsrInfo(data);
return data;
});
}
/**
* @ngdocs method
* @name refigureProfile.services:profile#updatePassword
* @methodOf refigureProfile.services:profile
* @param {String} password New password
* @returns {Object} promise
* @description
* Updates user password
*/
function updatePassword(password) {
return $http
.post(profileApiUri + '/password-change/', {
Password: password
})
.then(function (res) {
return utils.get(res, 'data.data');
});
}
}
})(window.angular);
| re-figure/refigure | front/app/components/profile/profile.service.js | JavaScript | mit | 2,235 |
import Bottom from './Bottom'
export default Bottom
| dingyoujian/webpack-react-demo | src/components/Bottom/index.js | JavaScript | mit | 53 |
Package.describe({
summary : "Slipstream - A light weight interface for Meteor development, supporting Meteorite"
});
Package.on_use(function (api) {
api.use(
[
"underscore",
"ejson"
],
[
"client",
"server"
]);
api.use('router', 'client');
api.add_files(
[
'lib/_inc/handlebars.js'
],
[
'client'
]
);
api.add_files(
[
'lib/_inc/prototype.string.js',
'lib/_inc/underscore.js'
],
[
'client',
'server'
]
);
api.add_files(
[
'lib/core/Slipstream.js',
'lib/core/Slipstream.defaults.js',
'lib/core/Slipstream.debug.js',
'lib/core/Slipstream.log.js'
],
[
'client',
'server'
]
);
api.add_files(
[
'lib/client/Slipstream.Session.js',
'lib/client/Slipstream.Router.js',
'lib/client/Slipstream.TemplateManager.js',
'lib/client/Slipstream.Template.js'
],
[
'client'
]
);
api.add_files(
[
'lib/collection/Slipstream.ColumnManager.js',
'lib/collection/Slipstream.Column.js',
'lib/collection/Slipstream.CollectionSetup.js',
'lib/collection/Slipstream.Collection.js',
'lib/server/Slipstream.Method.js',
'lib/core/Slipstream.Config.js',
'lib/Slipstream.Drift.js'
],
[
'client',
'server'
]
);
});
Package.on_test(function (api) {
api.use(
[
"underscore",
"underscore-string",
"ejson"
],
[
"client",
"server"
]);
api.use('router', 'client');
api.use(
[
'slipstream',
'tinytest',
'test-helpers'
],
[
'client',
'server'
]);
api.add_files('test/slipstream-test.js',
[
'client',
'server'
]);
});
| blitzcodes/slipstream-mrt | package.js | JavaScript | mit | 1,586 |
'use strict';
/* global it: false, describe: false */
var should = require('should');
var parser = require('../src/parser');
describe('parser.makeError()', function ()
{
it('should build the correct message', function ()
{
parser.makeError('error-message', 'file.html', 5)
.message.should.equal('error-message (file.html:5)');
});
it('should handle a missing message', function ()
{
parser.makeError(null, 'file.html', 5)
.message.should.equal('Unknown error (file.html:5)');
});
});
describe('parser.parse()', function ()
{
//helper function for constructing expected include results
function $include(file, line, vars)
{
return {
type: 'include',
file: file,
line: line,
vars: vars || {}
};
}
//helper method for attempting to parse something, and expecting an error to be thrown
function parseExpectThrow(opts)
{
should(function ()
{
parser.parse(opts.text, opts.file || 'test.html');
}).throw(opts.throws);
}
/***
* Positive tests (we don't expect to throw an error)
**/
it('should parse empty string', function ()
{
parser.parse('').should.eql([]);
});
it('should parse simple strings', function ()
{
parser.parse('hello').should.eql(['hello']);
parser.parse('hello\nworld').should.eql(['hello\nworld']);
parser.parse('hello <!-- world -->').should.eql(['hello <!-- world -->']);
});
it('should parse a single #include', function ()
{
var text = '<!-- #include file="file.html" -->';
parser.parse(text).should.eql([
$include('file.html', 1, {})
]);
});
it('should not depend upon whitespace in the #include', function ()
{
var expected = [$include('file.html', 1, {})];
parser.parse('<!-- #include file="file.html" -->').should.eql(expected);
parser.parse('<!-- #include file="file.html" -->').should.eql(expected);
parser.parse('<!--#include file="file.html"-->').should.eql(expected);
parser.parse('<!--\n\t#include file="file.html"\n -->').should.eql(expected);
});
it('should identify the line on which the #include started', function ()
{
for (var i = 1; i <= 10; i++)
{
testWithNewlinesPrefixed(i);
}
function testWithNewlinesPrefixed(linesBefore)
{
var newlines = new Array(linesBefore + 1).join('\n');
var text = newlines + '<!-- #include file="file.html" -->';
parser.parse(text).should.eql([
newlines,
$include('file.html', linesBefore + 1, {})]
);
}
});
it('should parse an #include with a single character before', function ()
{
var text = 'Q<!-- #include file="file.html" -->';
parser.parse(text).should.eql([
'Q',
$include('file.html', 1, {})
]);
});
it('should parse an #include with a single character after', function ()
{
var text = '<!-- #include file="file.html" -->Q';
parser.parse(text).should.eql([
$include('file.html', 1, {}),
'Q'
]);
});
it('should parse an #include with text before', function ()
{
var text = 'Hello, <!-- #include file="file.html" -->';
parser.parse(text).should.eql([
'Hello, ',
$include('file.html', 1, {})
]);
});
it('should parse an #include with text after', function ()
{
var text = '<!-- #include file="file.html" --> rocks!';
parser.parse(text).should.eql([
$include('file.html', 1, {}),
' rocks!'
]);
});
it('should parse an #include with text before and after', function ()
{
var text = 'Hello, <!-- #include file="file.html" --> rocks!';
parser.parse(text).should.eql([
'Hello, ',
$include('file.html', 1, {}),
' rocks!'
]);
});
it('should parse multiple #includes', function ()
{
var text = '<!-- #include file="file1.html" --><!-- #include file="file2.html" -->';
parser.parse(text).should.eql([
$include('file1.html', 1, {}),
$include('file2.html', 1, {})
]);
});
it('should parse multiple #includes with space between', function ()
{
var text = '<!-- #include file="file1.html" -->\n<!-- #include file="file2.html" -->';
parser.parse(text).should.eql([
$include('file1.html', 1, {}),
'\n',
$include('file2.html', 2, {})
]);
});
it('should parse a single valueless property', function ()
{
parser.parse('<!-- #include file="file.html" prop1 -->').should.eql([
$include('file.html', 1, {prop1: true})
]);
});
it('should parse multiple valueless properties', function ()
{
parser.parse('<!-- #include file="file.html" prop1 prop2 -->').should.eql([
$include('file.html', 1, {prop1: true, prop2: true})
]);
});
it('should parse a single unquoted property', function ()
{
parser.parse('<!-- #include file="file.html" prop1=val1 -->').should.eql([
$include('file.html', 1, {prop1: 'val1'})
]);
});
it('should parse a single empty unquoted property', function ()
{
parser.parse('<!-- #include file="file.html" prop1= -->').should.eql([
$include('file.html', 1, {prop1: ''})
]);
});
it('should parse multiple unquoted properties', function ()
{
parser.parse('<!-- #include file="file.html" prop1=val1 prop2=val2 -->').should.eql([
$include('file.html', 1, {prop1: 'val1', prop2: 'val2'})
]);
});
it('should parse a single quoted property', function ()
{
parser.parse('<!-- #include file="file.html" prop1="val1" -->').should.eql([
$include('file.html', 1, {prop1: 'val1'})
]);
});
it('should parse a single empty quoted property', function ()
{
parser.parse('<!-- #include file="file.html" prop1="" -->').should.eql([
$include('file.html', 1, {prop1: ''})
]);
});
it('should parse multiple quoted properties', function ()
{
parser.parse('<!-- #include file="file.html" prop1="val1" prop2="val2" -->').should.eql([
$include('file.html', 1, {prop1: 'val1', prop2: 'val2'})
]);
});
it('should parse a single quoted property with a strange name', function ()
{
parser.parse('<!-- #include file="file.html" ${_@^@_}$="strange" -->').should.eql([
$include('file.html', 1, {'${_@^@_}$': 'strange'})
]);
});
it('should parse a single quoted property with escaped quotes', function ()
{
parser.parse('<!-- #include file="file.html" prop1="this \\"special\\" value" -->').should.eql([
$include('file.html', 1, {prop1: 'this "special" value'})
]);
});
it('should parse a single quoted property with escaped newlines', function ()
{
parser.parse('<!-- #include file="file.html" prop1="this\\nvalue" -->').should.eql([
$include('file.html', 1, {prop1: 'this\nvalue'})
]);
});
it('should parse a single quoted property with escaped tabs', function ()
{
parser.parse('<!-- #include file="file.html" prop1="this\\tvalue" -->').should.eql([
$include('file.html', 1, {prop1: 'this\tvalue'})
]);
});
it('should parse a single quoted property with escaped backslashes', function ()
{
parser.parse('<!-- #include file="file.html" prop1="this \\\\ value" -->').should.eql([
$include('file.html', 1, {prop1: 'this \\ value'})
]);
});
it('should parse a mixture of properties that are quote/unquoted', function ()
{
parser.parse('<!-- #include file="file.html" prop1 prop2=val2 prop3="val3" prop4 -->').should.eql([
$include('file.html', 1, {prop1: true, prop2: 'val2', prop3: 'val3', prop4: true})
]);
});
it('should parse a mixture of properties that are quote/unquoted on multiple lines', function ()
{
parser.parse('<!-- #include file="file.html"\n\tprop1\n\tprop2=val2\n\tprop3="val3"\n\tprop4\n-->').should.eql([
$include('file.html', 1, {prop1: true, prop2: 'val2', prop3: 'val3', prop4: true})
]);
});
/***
* Negative tests (conditions under which we do expect to throw an error)
**/
it('should throw an exception if the file attribute is missing', function ()
{
parseExpectThrow({
text: '<!-- #include -->',
throws: 'Missing file= attribute in #include (test.html:1)'
});
});
it('should throw an exception if the #include is not closed', function ()
{
parseExpectThrow({
text: '<!-- #include',
throws: 'Unexpected end of input (attr name) (test.html:1)'
});
});
it('should throw an exception if the #include is not closed, regardless of which line', function ()
{
parseExpectThrow({
text: '\n<!--\n#include',
throws: 'Unexpected end of input (attr name) (test.html:3)'
});
});
it('should throw an exception if the attribute name never terminates', function ()
{
parseExpectThrow({
text: '<!-- #include file',
throws: 'Unexpected end of input (in attr name) (test.html:1)'
});
});
it('should throw an exception if the attribute name never terminates, regardless of which line', function ()
{
parseExpectThrow({
text: '\n<!--\n#include\nfile',
throws: 'Unexpected end of input (in attr name) (test.html:4)'
});
});
it('should throw an exception if the unquoted property never terminates', function ()
{
parseExpectThrow({
text: '<!-- #include file=foo.html',
throws: 'Unexpected end of input (unquoted value) (test.html:1)'
});
});
it('should throw an exception if the unquoted property never terminates, regardless of line', function ()
{
parseExpectThrow({
text: '\n<!--\n#include\nfile=foo.html',
throws: 'Unexpected end of input (unquoted value) (test.html:4)'
});
});
it('should throw an exception if the quoted property is not closed', function ()
{
parseExpectThrow({
text: '<!-- #include file="this is never closed',
throws: 'Unexpected end of input (unterminated quoted value) (test.html:1)'
});
});
it('should throw an exception if the quoted property is not closed, regardless of which line', function ()
{
parseExpectThrow({
text: '<!-- #include file="this is never closed',
throws: 'Unexpected end of input (unterminated quoted value) (test.html:1)'
});
});
});
| jffry/lb-include | test/parser.test.js | JavaScript | mit | 11,215 |
/*
* Konami Manager
* Copyright 2012-2014
* Authors: Tyrone Neill.
* All Rights Reserved.
* Use, reproduction, distribution, and modification of this code is subject to the terms and
* conditions of the MIT license, available at http://www.opensource.org/licenses/mit-license.php
*
* ARIA Support: Tyrone Neill
*
* Project: https://github.com/MonkeyMagiic/konamiManager
*/
var konamiManager = (function (ns) {
'use strict';
/**
* Collection of managed <code>Konami</code> objects.
* @type {Array} <Konami>
* @private
*/
var _konamis = [];
/**
* Attach a new Konami to the managed collection by specifying the combination to test against and
* the method/function to execute when the test succeeds.
*
* @param result callback when the <code>combination</code> has been executed successfully.
* @param combination sequence of characters (usually keyboard codes).
*/
ns.add = function (result, combination) {
_konamis.push(new Konami(result, combination));
}
/**
* @private
*/
window.addEventListener('keydown', function (event) {
var i = 0;
do {
_konamis[i].testSequence(event.keyCode);
i++;
} while (i < _konamis.length);
});
return ns;
/**
* Konami
*
* @param result callback when the <code>combination</code> has been executed successfully.
* @param combination sequence of characters (usually keyboard codes).
* @constructor
*/
function Konami(result, combination) {
/**
* Current position in the <code>combination</code>.
* @type {number}
* @private
*/
this._position = 0;
/**
* Result handler when the combination has successfully executed.
* @type {function}
* @private
*/
this._result = result;
/**
* The combination or sequence to test against
* @type {array}
* @private
*/
this._combination = combination;
/**
* Test a given code against the current <code>position</code>
* within the <code>combination</code>.
* @param code
*/
Konami.prototype.testSequence = function (code) {
if (this._combination[this._position++] === code) {
if (this._position === this._combination.length) {
this._result();
this._position = 0;
}
} else {
this._position = 0;
}
};
} // End of Konami.
})(window.konamiManager || {});
| MonkeyMagiic/konami-manager | konami.manager.js | JavaScript | mit | 2,671 |
'use strict';
require('mocha');
require('should');
var assert = require('assert');
var App = require('./fixtures/app');
var cu = require('./');
assert.hasAll = function(a, b) {
assert(cu.hasAll(a, b));
};
assert.contains = function(a, b) {
assert(cu.has(a, b));
};
describe('noop', function() {
it('should return undefined:', function() {
assert(typeof cu.noop({}) === 'undefined');
assert(typeof cu.noop('foo') === 'undefined');
});
});
describe('isObject', function() {
it('should be true if the value is an object:', function() {
assert(cu.isObject({}));
});
it('should be true if the value is a function:', function() {
assert(cu.isObject(function() {}));
});
it('should be false if the value is an object:', function() {
assert(!cu.isObject('foo'));
});
});
describe('identity', function() {
it('should return the given value:', function() {
assert.deepEqual(cu.identity({}), {});
assert.deepEqual(cu.identity('foo'), 'foo');
assert.deepEqual(cu.identity(['foo']), ['foo']);
assert.deepEqual(cu.identity([]), []);
});
});
describe('hasAll', function() {
describe('object', function() {
it('should be true if an object has all given value:', function() {
assert(cu.hasAll({
a: 'b',
b: 'c',
c: 'd'
}, 'c'));
assert(cu.hasAll({
a: 'b',
b: 'c',
c: 'd'
}, ['c', 'b']));
assert(cu.hasAll({
a: 'b',
b: 'c',
c: 'd'
}, ['a', 'b', 'c']));
});
it('should be false if an object does not have all given value:', function() {
assert(!cu.hasAll({
a: 'b',
b: 'c',
c: 'd'
}, 'd'));
assert(!cu.hasAll({
a: 'b',
b: 'c',
c: 'd'
}, ['c', 'b', 'z']));
});
});
describe('arrays', function() {
it('should be true if an array has all given value:', function() {
assert(cu.hasAll(['a', 'b', 'c'], 'c'));
assert(cu.hasAll(['a', 'b', 'c'], ['c', 'b']));
assert(cu.hasAll(['a', 'b', 'c'], ['a', 'b', 'c']));
});
it('should be false if an array does not have all given value:', function() {
assert(!cu.hasAll(['a', 'b', 'c'], 'd'));
assert(!cu.hasAll(['a', 'b', 'c'], ['c', 'b', 'z']));
});
});
});
describe('has', function() {
describe('objects', function() {
it('should return true if an array has the given value:', function() {
assert(cu.has({
a: 'b',
b: 'c',
c: 'd'
}, 'c'));
assert(cu.has({
a: 'b',
b: 'c',
c: 'd'
}, 'b'));
});
it('should return false if an array does not have the given value:', function() {
assert(!cu.has({
a: 'b',
b: 'c',
c: 'd'
}, 'd'));
assert(!cu.has({
a: 'b',
b: 'c',
c: 'd'
}, 'e'));
});
it('should return true if an array has any given values:', function() {
assert(cu.has({
a: 'b',
b: 'c',
c: 'd'
}, ['c', 'z']));
assert(cu.has({
a: 'b',
b: 'c',
c: 'd'
}, ['a', 'z']));
});
it('should return false if an array does not have any given values:', function() {
assert(!cu.has({
a: 'b',
b: 'c',
c: 'd'
}, ['x', 'z']));
assert(!cu.has({
a: 'b',
b: 'c',
c: 'd'
}, ['y', 'z']));
});
});
describe('arrays', function() {
it('should return true if an array has the given value:', function() {
assert(cu.has(['a', 'b', 'c'], 'c'));
assert(cu.has(['a', 'b', 'c'], 'b'));
});
it('should return false if an array does not have the given value:', function() {
assert(!cu.has(['a', 'b', 'c'], 'd'));
assert(!cu.has(['a', 'b', 'c'], 'e'));
});
it('should return true if an array has any given values:', function() {
assert(cu.has(['a', 'b', 'c'], ['c', 'z']));
assert(cu.has(['a', 'b', 'c'], ['a', 'z']));
});
it('should return false if an array does not have any given values:', function() {
assert(!cu.has(['a', 'b', 'c'], ['x', 'z']));
assert(!cu.has(['a', 'b', 'c'], ['y', 'z']));
});
});
it('should throw an error when the value is not an array or object:', function() {
(function() {
cu.has('foo');
}).should.throw('expected an array or object.');
});
});
describe('hasConstructor', function() {
it('should return true if a value is an object and has a constructor:', function() {
assert(cu.hasConstructor({
a: 'b',
b: 'c',
c: 'd'
}));
assert(cu.hasConstructor(function() {}));
assert(cu.hasConstructor(App));
assert(cu.hasConstructor(new App()));
assert(cu.hasConstructor(Object.create(new App())));
});
it('should return false if a value is not object:', function() {
assert(!cu.hasConstructor('foo'));
assert(!cu.hasConstructor(5));
});
it('should return false if an object does not have a constructor:', function() {
assert(!cu.hasConstructor(Object.create(null)));
assert(!cu.hasConstructor(null));
});
});
describe('nativeKeys', function() {
it('should get the native keys of an object:', function() {
assert.hasAll(cu.nativeKeys({
a: 'b',
b: 'c',
c: 'd'
}), ['a', 'b', 'c']);
assert.hasAll(cu.nativeKeys(function() {}), ['length', 'name', 'prototype']);
assert.hasAll(cu.nativeKeys(App), ['length', 'name', 'prototype']);
assert.hasAll(cu.nativeKeys(App.prototype), ['constructor', 'set', 'get', 'del']);
assert.hasAll(cu.nativeKeys(App.constructor), ['length', 'name', 'caller']);
assert.hasAll(cu.nativeKeys(App.prototype.constructor), ['length', 'caller']);
assert.hasAll(cu.nativeKeys(new App()), ['options']);
assert.hasAll(cu.nativeKeys(Object.create(new App())), []);
});
it('should return empty array if a value does not have native keys:', function() {
assert.deepEqual(cu.nativeKeys(Object.create(null)), []);
assert.deepEqual(cu.nativeKeys(null), []);
});
});
describe('getDescriptor', function() {
it('should get the native keys of an object:', function() {
assert.contains(cu.getDescriptor(App.prototype, 'count'), ['get',
'set'
]);
assert(typeof cu.getDescriptor(App.prototype, 'foo') ===
'undefined');
});
it('should throw an error when key is not a string:', function() {
(function() {
cu.getDescriptor({}, {}, null);
}).should.throw('expected key to be a string.');
});
it('should throw an error when receiver is not an object:', function() {
(function() {
cu.getDescriptor('foo');
}).should.throw('expected an object.');
});
});
describe('copyDescriptor', function() {
it('should copy a descriptor from the provider to receiver:', function() {
var proto = App.prototype;
var obj = {};
cu.copyDescriptor(obj, proto, 'count');
assert.contains(cu.getDescriptor(obj, 'count'), ['get', 'set']);
});
it('should do nothing when the descriptor does not exist:', function() {
var proto = App.prototype;
var obj = {};
cu.copyDescriptor(obj, proto, 'foo');
assert.deepEqual(obj, {});
});
it('should throw an error when name is not a string:', function() {
(function() {
cu.copyDescriptor({}, {}, null);
}).should.throw('expected name to be a string.');
});
it('should throw an error when receiver is not an object:', function() {
(function() {
cu.copyDescriptor('foo');
}).should.throw('expected receiving object to be an object.');
});
it('should throw an error when provider is not an object:', function() {
(function() {
cu.copyDescriptor({}, 'foo');
}).should.throw('expected providing object to be an object.');
});
});
describe('copy', function() {
it('should copy descriptors from the provider to receiver:', function() {
var proto = App.prototype;
var obj = {};
cu.copy(obj, proto);
assert.contains(cu.getDescriptor(obj, 'count'), ['get', 'set']);
});
it('should copy properties from the provider to receiver:', function() {
var proto = App.prototype;
var obj = {};
cu.copy(obj, proto);
obj.set('a', 'b');
assert(obj.a === 'b');
assert.contains(obj, ['get', 'set']);
});
it('should do nothing when the property does not exist:', function() {
var proto = App.prototype;
var obj = {};
cu.copy(obj, proto, 'foo');
assert.deepEqual(obj, {});
});
it('should throw an error when receiver is not an object:', function() {
(function() {
cu.copy('foo');
}).should.throw('expected receiving object to be an object.');
});
it('should throw an error when provider is not an object:', function() {
(function() {
cu.copy({}, 'foo');
}).should.throw('expected providing object to be an object.');
});
});
describe('inherit', function() {
it('should inherit descriptors from provider:', function() {
var proto = App.prototype;
var obj = {};
cu.inherit(obj, proto);
assert.contains(cu.getDescriptor(obj, 'count'), ['get', 'set']);
});
it('should inherit properties from provider:', function() {
var proto = App.prototype;
var obj = {};
cu.inherit(obj, proto);
obj.set('a', 'b');
assert(obj.a === 'b');
assert.contains(obj, ['get', 'set', 'del']);
});
it('should do nothing when the property does not exist:', function() {
var proto = App.prototype;
var obj = {};
cu.inherit(obj, proto, 'foo');
assert.deepEqual(obj, {});
});
it('should throw an error when receiver is not an object:', function() {
(function() {
cu.inherit('foo');
}).should.throw('expected receiving object to be an object.');
});
it('should throw an error when provider is not an object:', function() {
(function() {
cu.inherit({}, 'foo');
}).should.throw('expected providing object to be an object.');
});
});
describe('extend', function() {
var Parent;
var Ctor;
var proto;
beforeEach(function() {
Parent = function() {}
Parent.foo = 'bar';
Parent.prototype.a = function() {};
Parent.prototype.b = function() {};
Parent.prototype.c = function() {};
Object.defineProperty(Parent.prototype, 'count', {
get: function() {
return Object.keys(this).length;
},
set: function() {}
});
Ctor = function() {
Parent.call(this);
};
proto = App.prototype;
});
it('should add `Parent.prototype` to `Ctor` instances as `_parent_`', function() {
var extend = cu.extend(Parent);
var instance1 = new Ctor();
assert.equal(typeof instance1._parent_, 'undefined');
extend(Ctor);
var instance2 = new Ctor();
assert.equal(typeof instance2._parent_, 'object');
assert.deepEqual(instance2._parent_, Parent.prototype);
});
it('should access `Parent` methods through `_parent_`', function() {
Parent.prototype.upper = function(str) {
return str.toUpperCase();
};
var extend = cu.extend(Parent);
extend(Ctor);
var instance = new Ctor();
assert.equal(instance.upper('foo'), 'FOO');
instance.upper = function(str) {
return str;
};
assert.equal(instance.upper('foo'), 'foo');
instance.upper = function(str) {
return this._parent_.upper(str) + ' ' + str;
};
assert.equal(instance.upper('foo'), 'FOO foo');
});
it('should add static methods to Ctor:', function() {
var extend = cu.extend(Parent);
extend(Ctor);
assert(typeof Ctor.extend === 'function');
assert(Ctor.foo === 'bar');
});
it('should add prototype methods to Ctor:', function() {
var extend = cu.extend(Parent);
extend(Ctor);
assert(typeof Ctor.prototype.a === 'function');
assert(typeof Ctor.prototype.b === 'function');
assert(typeof Ctor.prototype.c === 'function');
});
it('should add descriptors to Ctor:', function() {
var extend = cu.extend(Parent);
extend(Ctor);
});
it('should copy prototype properties to Ctor:', function() {
var extend = cu.extend(Parent);
extend(Ctor, App.prototype);
assert(typeof Ctor.prototype.get === 'function');
assert(typeof Ctor.prototype.set === 'function');
assert(typeof Ctor.prototype.del === 'function');
});
it('should add a mixin method to the prototype of Ctor using `extend` function:', function() {
var extend = cu.extend(Parent, function(Child) {
Child.prototype.mixin = function(key, val) {
Child.prototype[key] = val;
};
});
extend(Ctor, App.prototype);
assert(typeof Ctor.prototype.mixin === 'function');
assert(typeof Ctor.prototype.get === 'function');
assert(typeof Ctor.prototype.set === 'function');
assert(typeof Ctor.prototype.del === 'function');
});
it('should mixin methods to the Ctor.prototype using `extend` function:', function() {
var extend = cu.extend(Parent, function(Child) {
Child.prototype.mixin = function(key, val) {
Child.prototype[key] = val;
};
});
extend(Ctor, App.prototype);
var app = new Ctor();
app.mixin('foo', function() {});
assert.equal(typeof Ctor.prototype.foo, 'function');
});
it('should throw an error when Parent is not a function:', function() {
(function() {
cu.extend('foo');
}).should.throw('expected Parent to be a function.');
});
it('should throw an error when Ctor is not a function:', function() {
(function() {
cu.extend(function Foo() {})('bar')
}).should.throw('expected Ctor to be a function.');
});
});
| jonschlinkert/class-utils | test.js | JavaScript | mit | 13,602 |
define('ivy/ClassNode', [], function() {
return FirClass(
function ClassNode() {
throw new Error('Cannot create instance of abstract class!');
}, {
/** Analogue to IvyNodeRange opSlice(); in D impl */
range: function() {
throw new Error('Not implemented!');
},
/** Analogue to IClassNode opSlice(size_t, size_t); in D impl */
slice: function(start, end) {
throw new Error('Not implemented!');
},
/** Analogue to:
* IvyData opIndex(string);
* IvyData opIndex(size_t);
* in D impl */
at: function(index) {
throw new Error('Not implemented!');
},
/** Analogue to IvyData __getAttr__(string); in D impl */
getAttr: function(name) {
throw new Error('Not implemented!');
},
/** Analogue to void __setAttr__(IvyData, string); in D impl */
setAttr: function(value, name) {
throw new Error('Not implemented!');
},
/** Analogue to IvyData __serialize__(); in D impl */
serialize: function() {
throw new Error('Not implemented!');
},
/** Analogue to size_t length() @property; in D impl */
getLength: function() {
throw new Error('Not implemented!');
}
});
}); | uranuz/declarative | ivy/ClassNode.js | JavaScript | mit | 1,126 |
/*global define:true */
define(
[
'jquery',
'underscore',
'backbone',
'mustache',
'collections/ChatMessages',
'views/MenuView',
'views/ChatView',
'views/PeersView',
'views/UploaderView',
'views/VideoView',
'views/DocumentViewFactory',
'text!templates/main.tpl'
],
function ($, _, Backbone, Mustache, Messages, MenuView, ChatView, PeersView, UploaderView, VideoView, DocumentViewFactory, mainTemplate) {
'use strict';
console.log(Backbone);
return Backbone.View.extend({
initialize: function (opts) {
opts = opts || {};
this.shares = opts.shares;
this.messages = opts.messages;
this.peers = opts.peers;
this.room = opts.room;
this._shareViewCache = [];
this._videoView = null;
this._currentShareView = null;
},
render: function () {
var self = this;
this.$el.html(Mustache.render(mainTemplate, {room: this.room}));
this.menu = new MenuView({collection: this.shares, el: 'header.masthead', room: this.room});
this.menu.render();
//add uploader
this.uploader = new UploaderView().render();
$('#chat-container').append(this.uploader.$el);
this.uploader.on('doc', function (doc) {
self.shares.add(doc);
});
//add chat
this.chat = new ChatView({collection: this.messages, peers: this.peers});
$('#chat-container').append(this.chat.$el);
this.chat.render();
//and finally the peers views ( local and remote )
this.peersView = new PeersView({collection: this.peers, room: this.room}).render();
if (this.shares.length) {
var m = this.shares.at(0);
this.showShare(m.id);
}
$(document).foundation();
return this;
},
showVideo: function (peerId, videoId) {
var peer = this.peers.get(peerId);
if (!peer) {
return;
}
var video = peer.get('streams')[videoId];
if (!video) {
return;
}
this.menu.activate('');
if (this._currentShareView) {
this._currentShareView.$el.hide();
}
if (this._videoView) {
this._videoView.remove();
}
this._videoView = new VideoView({video: video});
this._videoView.$el.appendTo('#main-content');
this._videoView.render();
},
showShare: function (id) {
if (!this.shares.get(id)){
console.log(' doc unknown');
return;
}
this.menu.activate(id);
if (this._currentShareView) {
this._currentShareView.$el.hide();
}
if (this._videoView) {
this._videoView.remove();
}
if (this._shareViewCache[id]) {
this._currentShareView = this._shareViewCache[id];
this._currentShareView.$el.show();
} else {
this._currentShareView = this._shareViewCache[id] = DocumentViewFactory.makeView({peers: this.peers, model: this.shares.get(id) });
this._currentShareView.$el.appendTo('#main-content');
this._currentShareView.render();
}
},
remove: function () {
this.menu.remove();
this.uploader.remove();
this.chat.remove();
this.peersView.remove();
_.each(this._shareViewCache, function (shareView) {
shareView.remove();
});
if (this._videoView) {
this._videoView.remove();
}
return Backbone.View.prototype.remove.apply(this, arguments);
}
});
});
| fbeauchamp/striim | app/scripts/views/MainView.js | JavaScript | mit | 4,430 |
(function(JST) {
var TopNavigation;
TopNavigation = (function() {
function TopNavigation() {}
TopNavigation.prototype.parseData = function(args) {
return args;
};
TopNavigation.prototype.render = function(obj) {
var $root;
if (obj == null) {
obj = {};
}
return $root = $("#" + obj.elemHash);
};
return TopNavigation;
})();
return assignTmpl(JST.menus, 'topnavigation', 'menus.topnavigation', new TopNavigation);
})(this.JST);
| carlosmarte/html5-bootstrap-v3-jst | lib/scripts/src/menus/topnavigation.js | JavaScript | mit | 500 |
"use strict";
/*
* Serial ports
* http://wiki.osdev.org/UART
* https://github.com/s-macke/jor1k/blob/master/js/worker/dev/uart.js
* https://www.freebsd.org/doc/en/articles/serial-uart/
*/
/** @const */
var DLAB = 0x80;
/** @const */ var UART_IER_MSI = 0x08; /* Modem Status Changed int. */
/** @const */ var UART_IER_THRI = 0x02; /* Enable Transmitter holding register int. */
/** @const */ var UART_IER_RDI = 0x01; /* Enable receiver data interrupt */
/** @const */var UART_IIR_MSI = 0x00; /* Modem status interrupt (Low priority) */
/** @const */var UART_IIR_NO_INT = 0x01;
/** @const */var UART_IIR_THRI = 0x02; /* Transmitter holding register empty */
/** @const */var UART_IIR_RDI = 0x04; /* Receiver data interrupt */
/** @const */var UART_IIR_RLSI = 0x06; /* Receiver line status interrupt (High p.) */
/** @const */var UART_IIR_CTI = 0x0c; /* Character timeout */
/** @const */ var UART_LSR_DATA_READY = 0x1; // data available
/** @const */ var UART_LSR_TX_EMPTY = 0x20; // TX (THR) buffer is empty
/** @const */ var UART_LSR_TRANSMITTER_EMPTY = 0x40; // TX empty and line is idle
/**
* @constructor
* @param {CPU} cpu
* @param {number} port
* @param {BusConnector} bus
*/
function UART(cpu, port, bus)
{
/** @const @type {BusConnector} */
this.bus = bus;
/** @const @type {CPU} */
this.cpu = cpu;
this.ints = 1 << UART_IIR_THRI;
this.baud_rate = 0;
this.line_control = 0;
// line status register
this.lsr = UART_LSR_TRANSMITTER_EMPTY | UART_LSR_TX_EMPTY;
this.fifo_control = 0;
// interrupts enable
this.ier = 0;
// interrupt identification register
this.iir = UART_IIR_NO_INT;
this.modem_control = 0;
this.modem_status = 0;
this.scratch_register = 0;
this.irq = 0;
this.input = new ByteQueue(4096);
this.current_line = [];
if(port === 0x3E8 || port === 0x3F8)
{
this.irq = 4;
}
else if(port === 0x3E8 || port === 0x3E8)
{
this.irq = 3;
}
else
{
dbg_log("Invalid port: " + h(port), LOG_SERIAL);
return;
}
this.bus.register("serial0-input", function(data)
{
this.data_received(data);
}, this);
var io = cpu.io;
io.register_write(port, this, function(out_byte)
{
this.write_data(out_byte);
}, function(out_word)
{
this.write_data(out_word & 0xFF);
this.write_data(out_word >> 8);
});
io.register_write(port | 1, this, function(out_byte)
{
if(this.line_control & DLAB)
{
this.baud_rate = this.baud_rate & 0xFF | out_byte << 8;
dbg_log("baud rate: " + h(this.baud_rate), LOG_SERIAL);
}
else
{
this.ier = out_byte & 0xF;
dbg_log("interrupt enable: " + h(out_byte), LOG_SERIAL);
this.CheckInterrupt();
}
});
io.register_read(port, this, function()
{
if(this.line_control & DLAB)
{
return this.baud_rate & 0xFF;
}
else
{
var data = this.input.shift();
if(data === -1)
{
dbg_log("Read input empty", LOG_SERIAL);
}
else
{
dbg_log("Read input: " + h(data), LOG_SERIAL);
}
if(this.input.length === 0)
{
this.lsr &= ~UART_LSR_DATA_READY;
this.ClearInterrupt(UART_IIR_CTI);
}
return data;
}
});
io.register_read(port | 1, this, function()
{
if(this.line_control & DLAB)
{
return this.baud_rate >> 8;
}
else
{
return this.ier & 0xF;
}
});
io.register_read(port | 2, this, function()
{
var ret = this.iir & 0xF | 0xC0;
dbg_log("read interrupt identification: " + h(this.iir), LOG_SERIAL);
if (this.iir == UART_IIR_THRI) {
this.ClearInterrupt(UART_IIR_THRI);
}
return ret;
});
io.register_write(port | 2, this, function(out_byte)
{
dbg_log("fifo control: " + h(out_byte), LOG_SERIAL);
this.fifo_control = out_byte;
});
io.register_read(port | 3, this, function()
{
dbg_log("read line control: " + h(this.line_control), LOG_SERIAL);
return this.line_control;
});
io.register_write(port | 3, this, function(out_byte)
{
dbg_log("line control: " + h(out_byte), LOG_SERIAL);
this.line_control = out_byte;
});
io.register_read(port | 4, this, function()
{
return this.modem_control;
});
io.register_write(port | 4, this, function(out_byte)
{
dbg_log("modem control: " + h(out_byte), LOG_SERIAL);
this.modem_control = out_byte;
});
io.register_read(port | 5, this, function()
{
dbg_log("read line status: " + h(this.lsr), LOG_SERIAL);
return this.lsr;
});
io.register_write(port | 5, this, function(out_byte)
{
dbg_log("Factory test write", LOG_SERIAL);
});
io.register_read(port | 6, this, function()
{
dbg_log("read modem status: " + h(this.modem_status), LOG_SERIAL);
return this.modem_status;
});
io.register_write(port | 6, this, function(out_byte)
{
dbg_log("Unkown register write (base+6)", LOG_SERIAL);
});
io.register_read(port | 7, this, function()
{
return this.scratch_register;
});
io.register_write(port | 7, this, function(out_byte)
{
this.scratch_register = out_byte;
});
}
UART.prototype.get_state = function()
{
var state = [];
state[0] = this.ints;
state[1] = this.baud_rate;
state[2] = this.line_control;
state[3] = this.lsr;
state[4] = this.fifo_control;
state[5] = this.ier;
state[6] = this.iir;
state[7] = this.modem_control;
state[8] = this.modem_status;
state[9] = this.scratch_register;
state[10] = this.irq;
return state;
};
UART.prototype.set_state = function(state)
{
this.ints = state[0];
this.baud_rate = state[1];
this.line_control = state[2];
this.lsr = state[3];
this.fifo_control = state[4];
this.ier = state[5];
this.iir = state[6];
this.modem_control = state[7];
this.modem_status = state[8];
this.scratch_register = state[9];
this.irq = state[10];
};
UART.prototype.CheckInterrupt = function() {
if ((this.ints & (1 << UART_IIR_CTI)) && (this.ier & UART_IER_RDI)) {
this.iir = UART_IIR_CTI;
this.cpu.device_raise_irq(this.irq);
} else
if ((this.ints & (1 << UART_IIR_THRI)) && (this.ier & UART_IER_THRI)) {
this.iir = UART_IIR_THRI;
this.cpu.device_raise_irq(this.irq);
} else
if ((this.ints & (1 << UART_IIR_MSI)) && (this.ier & UART_IER_MSI)) {
this.iir = UART_IIR_MSI;
this.cpu.device_raise_irq(this.irq);
} else {
this.iir = UART_IIR_NO_INT;
this.cpu.device_lower_irq(this.irq);
}
};
UART.prototype.ThrowInterrupt = function(line) {
this.ints |= (1 << line);
this.CheckInterrupt();
};
UART.prototype.ClearInterrupt = function(line) {
this.ints &= ~(1 << line);
this.CheckInterrupt();
};
/**
* @param {number} data
*/
UART.prototype.data_received = function(data)
{
dbg_log("input: " + h(data), LOG_SERIAL);
this.input.push(data);
this.lsr |= UART_LSR_DATA_READY;
this.ThrowInterrupt(UART_IIR_CTI);
};
UART.prototype.write_data = function(out_byte)
{
if(this.line_control & DLAB)
{
this.baud_rate = this.baud_rate & ~0xFF | out_byte;
return;
}
dbg_log("data: " + h(out_byte), LOG_SERIAL);
this.ThrowInterrupt(UART_IIR_THRI);
if(out_byte === 0xFF)
{
return;
}
var char = String.fromCharCode(out_byte);
this.bus.send("serial0-output-char", char);
this.current_line.push(out_byte);
if(char === "\n")
{
dbg_log("SERIAL: " + String.fromCharCode.apply("", this.current_line).trimRight());
this.bus.send("serial0-output-line", String.fromCharCode.apply("", this.current_line));
this.current_line = [];
}
};
| nimdavtanke/www | virt.nimda.pro/src/uart.js | JavaScript | mit | 8,259 |
(function() {
'use strict';
angular.module('gradebookApp')
.controller('GradesListCtrl', GradesListCtrl);
function GradesListCtrl($mdDialog, $mdToast, GradeService) {
var ctrl = this;
ctrl.GradeService = GradeService;
ctrl.newStudent = newStudent;
ctrl.updateStudent = updateStudent;
ctrl.removeStudent = removeStudent;
/**
* Create a new student.
* @param {Event} ev
*/
function newStudent(ev) {
// TODO: Add form validation to dialog
var confirm = $mdDialog.prompt()
.title('What is your student\'s name?')
.placeholder('John or Jane Doe')
.targetEvent(ev)
.ok('Done')
.cancel('Cancel');
$mdDialog.show(confirm)
.then(function(result) {
GradeService.create(result, null);
});
}
/**
* Update the grade.
* @param {Object} grade Grade.
*/
function updateStudent(grade) {
if (_.isPlainObject(grade) && !_.isEmpty(grade)) {
GradeService.update(grade.id, grade)
.then(function() {
$mdToast.show(
$mdToast.simple()
.textContent('Saved Changes')
.position('bottom right')
.hideDelay(3000)
);
});
}
}
/**
* Remove the student.
* @param {Object} grade Grade.
*/
function removeStudent(grade) {
if (_.isPlainObject(grade) && !_.isEmpty(grade)) {
GradeService.remove(grade.id)
.then(function() {
$mdToast.show(
$mdToast.simple()
.textContent('Record Deleted')
.position('bottom right')
.hideDelay(3000)
);
});
}
}
}
})(); | spencermefford/gradebook | app/grades/grades-list.controller.js | JavaScript | mit | 1,767 |
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.loadSchemas = loadSchemas;
exports.default = exports.validateUseCase = exports.validateScenario = exports.validateStep = exports.validateBranch = exports.validateBuild = void 0;
var _path = _interopRequireDefault(require("path"));
var _fs = _interopRequireDefault(require("fs"));
var _tv = _interopRequireDefault(require("tv4"));
var _glob = _interopRequireDefault(require("glob"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var entitySchemas = loadSchemas();
function loadSchemas() {
// load json files in-sync. otherwise we'd have to make "validate" also async...!
var schemas = {};
var schemaRootDirPath = _path.default.resolve(__dirname, './validationSchemas');
_glob.default.sync('./*.json', {
cwd: schemaRootDirPath
}).forEach(function (schemaFile) {
var content = _fs.default.readFileSync(_path.default.join(schemaRootDirPath, schemaFile), 'utf-8');
schemas[_path.default.basename(schemaFile, '.json')] = JSON.parse(content);
});
return schemas;
}
/**
* add "mixins" to tv4 (they must have the "id" property set)
* This is used for referencing via "$ref"
*/
_tv.default.addSchema(entitySchemas.labels);
function toMessage(validationResult) {
var messageParts = validationResult.errors.map(function (error) {
return "".concat(error.message, " (").concat(error.dataPath, ", ").concat(error.schemaPath, ")");
});
return messageParts.join(' | ');
}
function validate(schemaName, entity) {
var schema = entitySchemas[schemaName];
if (!schema) {
throw new Error("No Schema for ".concat(schemaName));
}
var result = _tv.default.validateMultiple(entity, schema);
if (!result.valid) {
throw new Error("".concat(schemaName, ": ").concat(toMessage(result)));
}
}
var validateBuild = validate.bind(undefined, 'build');
exports.validateBuild = validateBuild;
var validateBranch = validate.bind(undefined, 'branch');
exports.validateBranch = validateBranch;
var validateStep = validate.bind(undefined, 'step');
exports.validateStep = validateStep;
var validateScenario = validate.bind(undefined, 'scenario');
exports.validateScenario = validateScenario;
var validateUseCase = validate.bind(undefined, 'useCase');
exports.validateUseCase = validateUseCase;
var _default = {
validateBuild: validateBuild,
validateBranch: validateBranch,
validateUseCase: validateUseCase,
validateStep: validateStep,
validateScenario: validateScenario,
loadSchemas: loadSchemas
};
exports.default = _default; | scenarioo/scenarioo-js | lib/docuWriter/entityValidator.js | JavaScript | mit | 2,613 |
Cannot GET /javascripts/models/post.js
| xcoderzach/LiveDocument | test/models/postClient.js | JavaScript | mit | 39 |
var express = require('express');
var path = require('path');
var app = express();
var server = require("http").Server(app);
var io = require("socket.io")(server);
var dnode = require('dnode');
var bodyParser = require('body-parser');
var Sequelize = require('sequelize');
var Umzug = require('umzug');
app.use(bodyParser.json());
var indexRoutes = require('./routes/index.js');
app.use('/', indexRoutes);
var profileRoutes = require('./routes/profile.js');
app.use('/profile1', profileRoutes);
app.use('/client', express.static(path.resolve(__dirname, 'client')))
app.use('/node_modules', express.static(path.resolve(__dirname, 'node_modules')))
app.set('views', './views')
app.set('view engine', 'pug');
var sequelizeInstance = new Sequelize('thermometer', 'thermometer', 'thermometer', {
host: 'localhost',
dialect: 'postgres',
pool: {
max: 5,
min: 0,
idle: 10000
}
});
var umzug = new Umzug({
storage: 'sequelize',
storageOptions: {
sequelize: sequelizeInstance,
},
migrations: {
params: [sequelizeInstance.getQueryInterface(), sequelizeInstance.constructor, function() {
throw new Error('Migration tried to use old style "done" callback. Please upgrade to "umzug" and return a promise instead.');
}],
path: './migrations',
pattern: /\.js$/
}
});
umzug.up().then(function() {
console.log('Migration complete!');
server.listen(3000, function () {
console.log('App running on port 3000.');
});
});
io.on("connection", function(socket){
console.log('connection established');
socket.on('startPollingProbe', function(msg){
console.log('socket message received');
var client = dnode({
poll : function (cb) {
console.log('Poll');
cb();
}
});
client.connect(6060, function (remote, conn) {
remote.startProbe(function (curTemp) {
io.emit('temperatureReading', curTemp);
});
});
});
}); | bobsakson/GrillThermometer | web/index.js | JavaScript | mit | 2,102 |
'use strict';
const path = require('path');
const fs = require('fs');
const { default: resolve } = require('@rollup/plugin-node-resolve');
const commonjs = require('@rollup/plugin-commonjs');
const nodeBuiltins = require('rollup-plugin-node-builtins');
const globals = require('rollup-plugin-node-globals');
const { default: babel } = require('@rollup/plugin-babel');
const istanbul = require('rollup-plugin-istanbul');
const rollupConfig = require('./rollup.config');
let config;
const isCI =
typeof process.env.CI !== 'undefined' && process.env.CI !== 'false';
const isPR =
typeof process.env.TRAVIS_PULL_REQUEST !== 'undefined' &&
process.env.TRAVIS_PULL_REQUEST !== 'false';
const local = !isCI || (isCI && isPR);
const port = 0;
if (local) {
config = {
browsers: ['Chrome']
};
} else {
config = {
hostname: 'bs-local.com',
browserStack: {
username: process.env.BROWSER_STACK_USERNAME,
accessKey: process.env.BROWSER_STACK_ACCESS_KEY,
startTunnel: true,
project: 'jsonapi-data-manager',
name: 'Automated (Karma)',
build: 'Automated (Karma)'
},
customLaunchers: {
'BS-Chrome': {
base: 'BrowserStack',
browser: 'Chrome',
os: 'Windows',
'os_version': '7',
project: 'jsonapi-data-manager',
build: 'Automated (Karma)',
name: 'Chrome'
},
'BS-Firefox': {
base: 'BrowserStack',
browser: 'Firefox',
os: 'Windows',
'os_version': '7',
project: 'jsonapi-data-manager',
build: 'Automated (Karma)',
name: 'Firefox'
},
'BS-IE11': {
base: 'BrowserStack',
browser: 'IE',
'browser_version': '11',
os: 'Windows',
'os_version': '7',
project: 'jsonapi-data-manager',
build: 'Automated (Karma)',
name: 'IE11'
}
},
browsers: ['BS-Chrome', 'BS-Firefox', 'BS-IE11']
};
}
module.exports = function (baseConfig) {
baseConfig.set({
basePath: '',
frameworks: ['mocha', 'fixture'],
files: ['test/**/*.html', { pattern: 'test/**/*.js', watched: false }],
exclude: [],
preprocessors: {
'test/**/*.html': ['html2js'],
'test/**/*.js': ['rollup', 'sourcemap']
},
reporters: ['mocha', 'coverage-istanbul'],
port: port,
colors: true,
logLevel: baseConfig.LOG_INFO,
autoWatch: false,
client: {
captureConsole: true
},
browserConsoleLogOptions: {
level: 'log',
format: '%b %T: %m',
terminal: true
},
rollupPreprocessor: {
plugins: [
nodeBuiltins(),
babel({
exclude: 'node_modules/**',
babelHelpers: 'runtime'
}),
resolve({
preferBuiltins: true
}),
commonjs(),
babel({
include: 'node_modules/{has-flag,supports-color}/**',
babelHelpers: 'runtime',
babelrc: false,
configFile: path.resolve(__dirname, '.babelrc')
}),
globals(),
...rollupConfig.plugins.filter(
({ name }) => !['babel'].includes(name)
),
istanbul({
exclude: ['test/**/*.js', 'node_modules/**/*']
})
],
output: {
format: 'iife',
name: 'jsonapiDataManager',
sourcemap: baseConfig.autoWatch ? false : 'inline', // Source map support has weird behavior in watch mode
intro: 'window.TYPED_ARRAY_SUPPORT = false;' // IE9
}
},
coverageIstanbulReporter: {
dir: path.join(__dirname, 'coverage/%browser%'),
fixWebpackSourcePaths: true,
reports: ['html', 'text'],
thresholds: {
global: JSON.parse(
fs.readFileSync(path.join(__dirname, '.nycrc'), 'utf8')
)
}
},
singleRun: true,
concurrency: Infinity,
...config
});
};
| niksy/jsonapi-datastore | karma.conf.js | JavaScript | mit | 3,503 |
// In production, we register a service worker to serve assets from local cache.
// This lets the app load faster on subsequent visits in production, and gives
// it offline capabilities. However, it also means that developers (and users)
// will only see deployed updates on the "N+1" visit to a page, since previously
// cached resources are updated in the background.
// To learn more about the benefits of this model, read https://goo.gl/KwvDNy.
// This link also includes instructions on opting out of this behavior.
const isLocalhost = Boolean(
window.location.hostname === 'localhost' ||
// [::1] is the IPv6 localhost address.
window.location.hostname === '[::1]' ||
// 127.0.0.1/8 is considered localhost for IPv4.
window.location.hostname.match(
/^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
)
)
export default function register () {
if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
// The URL constructor is available in all browsers that support SW.
const publicUrl = new URL(process.env.PUBLIC_URL, window.location)
if (publicUrl.origin !== window.location.origin) {
// Our service worker won't work if PUBLIC_URL is on a different origin
// from what our page is served on. This might happen if a CDN is used to
// serve assets see https://github.com/facebookincubator/create-react-app/issues/2374
return
}
window.addEventListener('load', () => {
const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`
if (isLocalhost) {
// This is running on localhost. Lets check if a service worker still exists or not.
checkValidServiceWorker(swUrl)
} else {
// Is not local host. Just register service worker
registerValidSW(swUrl)
}
})
}
}
function registerValidSW (swUrl) {
navigator.serviceWorker
.register(swUrl)
.then(registration => {
registration.onupdatefound = () => {
const installingWorker = registration.installing
installingWorker.onstatechange = () => {
if (installingWorker.state === 'installed') {
if (navigator.serviceWorker.controller) {
// At this point, the old content will have been purged and
// the fresh content will have been added to the cache.
// It's the perfect time to display a "New content is
// available please refresh." message in your web app.
console.log('New content available')
} else {
// At this point, everything has been precached.
// It's the perfect time to display a
// "Content is cached for offline use." message.
console.log('Content is cached for offline use.')
}
}
}
}
})
.catch(error => {
console.error('Error during service worker registration:', error)
})
}
function checkValidServiceWorker (swUrl) {
// Check if the service worker can be found. If it can't reload the page.
fetch(swUrl)
.then(response => {
// Ensure service worker exists, and that we really are getting a JS file.
if (
response.status === 404 ||
response.headers.get('content-type').indexOf('javascript') === -1
) {
// No service worker found. Probably a different app. Reload the page.
navigator.serviceWorker.ready.then(registration => {
registration.unregister().then(() => {
window.location.reload()
})
})
} else {
// Service worker found. Proceed as normal.
registerValidSW(swUrl)
}
})
.catch(() => {
console.log(
'No internet connection found. App is running in offline mode.'
)
})
}
export function unregister () {
if ('serviceWorker' in navigator) {
navigator.serviceWorker.ready.then(registration => {
registration.unregister()
})
}
}
| vfeskov/win-a-beer | client/src/registerServiceWorker.js | JavaScript | mit | 3,981 |
"use strict";
console.log("**** Starting ht-docker-traffic ****");
const plugins = require("./traffic.plugins");
/**************************************************************
************ Initial Start ********
**************************************************************/
plugins.beautylog.log("Modules loaded! Now running initial checks");
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxDQUFDLEdBQUcsQ0FBQyxzQ0FBc0MsQ0FBQyxDQUFDO0FBQ3BELE1BQVksT0FBTyxXQUFNLG1CQUFtQixDQUFDLENBQUE7QUFHN0M7O2dFQUVnRTtBQUNoRSxPQUFPLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyw0Q0FBNEMsQ0FBQyxDQUFDIn0= | HostToday/ht-docker-traffic | dist/index.js | JavaScript | mit | 730 |
const _ = require('lodash');
const PostModel = require('mongoose').model('Post');
exports.createPost = (req, res) => {
const postDetails = _.cloneDeep(req.body);
postDetails.startDate = new Date(parseInt(postDetails.startDate, 10));
postDetails.duration = parseInt(postDetails.duration, 10);
postDetails.stipend = parseInt(postDetails.stipend, 10);
postDetails.applyBy = new Date(parseInt(postDetails.applyBy, 10));
const newPost = new PostModel(postDetails);
newPost.position = newPost.position.trim();
newPost.company = newPost.company.trim();
newPost.location = newPost.location.trim();
if (_.has(newPost, 'description')) {
newPost.description = newPost.description.trim();
}
newPost.postedOn = new Date();
newPost.save((err) => {
if (err) {
console.log(err);
res.status(500).json({ message: 'database error' });
} else {
console.log('A new post added');
res.status(200).json({ message: 'post created' });
}
});
};
exports.getAllPost = (req, res) => {
PostModel.find({ }, (err, docs) => {
if (err) res.status(500).json({ message: 'database error' });
else res.status(200).json(docs);
});
};
exports.getPost = (req, res) => {
PostModel.findById({ _id: req.params.id }, (err, docs) => {
if (err || !docs) res.status(500).json({ message: 'database error' });
else { res.status(200).json(docs); }
});
};
exports.updatePost = (req, res) => {
PostModel.findByIdAndUpdate({ _id: req.params.id }, req.body, (err, docs) => {
if (err || !docs) res.status(500).json({ message: 'database error' });
else res.status(200).json({ message: 'post updated' });
});
};
exports.deletePost = (req, res) => {
PostModel.findByIdAndRemove(req.params.id, (err, docs) => {
if (err || !docs) res.status(500).json({ message: 'database error' });
else res.status(200).json({ message: 'post deleted' });
});
};
| sagnikm95/internship-portal | server/controllers/post.js | JavaScript | mit | 1,909 |
function show(elem, bool) {
if (bool) {
elem.getElementsByTagName('ul')[0].style.display = "block"
}
}
function hide(elem, bool) {
if (bool) {
elem.getElementsByTagName('ul')[0].style.display = "none"
}
}
function toggleDebug() {
if (document.querySelector(".debug-panel").classList.contains("debug-panel--open")) {
closeDebug()
} else {
openDebug()
}
}
function openDebug() {
document.querySelector(".debug-panel").classList.add("debug-panel--open")
document.querySelector(".page-container").classList.add("has-debug-panel")
}
function closeDebug() {
document.querySelector(".debug-panel").classList.remove("debug-panel--open")
document.querySelector(".page-container").classList.remove("has-debug-panel")
}
document.addEventListener("DOMContentLoaded", function(event) {
// Reveal images on scroll
window.sr = ScrollReveal({reset : true,});
sr.reveal('img');
// Make menu show up on scroll up, but hide on scroll down (for later, have to fix a few things first)
var header = document.querySelector(".headroom")
var footer = document.querySelector("footer")
var headroom = new Headroom(header)
var footerroom = new Headroom(footer)
headroom.init();
footerroom.init();
});
| Yatoom/AdaptiveWebBasedSystems | src/js/script.js | JavaScript | mit | 1,239 |
define('ember-ajax/errors', ['exports', 'ember'], function (exports, _ember) {
'use strict';
exports.AjaxError = AjaxError;
exports.InvalidError = InvalidError;
exports.UnauthorizedError = UnauthorizedError;
exports.ForbiddenError = ForbiddenError;
exports.BadRequestError = BadRequestError;
exports.NotFoundError = NotFoundError;
exports.TimeoutError = TimeoutError;
exports.AbortError = AbortError;
exports.ConflictError = ConflictError;
exports.ServerError = ServerError;
exports.isAjaxError = isAjaxError;
exports.isUnauthorizedError = isUnauthorizedError;
exports.isForbiddenError = isForbiddenError;
exports.isInvalidError = isInvalidError;
exports.isBadRequestError = isBadRequestError;
exports.isNotFoundError = isNotFoundError;
exports.isTimeoutError = isTimeoutError;
exports.isAbortError = isAbortError;
exports.isConflictError = isConflictError;
exports.isServerError = isServerError;
exports.isSuccess = isSuccess;
var EmberError = _ember['default'].Error;
/**
* @class AjaxError
* @private
*/
function AjaxError(errors) {
var message = arguments.length <= 1 || arguments[1] === undefined ? 'Ajax operation failed' : arguments[1];
EmberError.call(this, message);
this.errors = errors || [{
title: 'Ajax Error',
detail: message
}];
}
AjaxError.prototype = Object.create(EmberError.prototype);
/**
* @class InvalidError
* @public
* @extends AjaxError
*/
function InvalidError(errors) {
AjaxError.call(this, errors, 'Request was rejected because it was invalid');
}
InvalidError.prototype = Object.create(AjaxError.prototype);
/**
* @class UnauthorizedError
* @public
* @extends AjaxError
*/
function UnauthorizedError(errors) {
AjaxError.call(this, errors, 'Ajax authorization failed');
}
UnauthorizedError.prototype = Object.create(AjaxError.prototype);
/**
* @class ForbiddenError
* @public
* @extends AjaxError
*/
function ForbiddenError(errors) {
AjaxError.call(this, errors, 'Request was rejected because user is not permitted to perform this operation.');
}
ForbiddenError.prototype = Object.create(AjaxError.prototype);
/**
* @class BadRequestError
* @public
* @extends AjaxError
*/
function BadRequestError(errors) {
AjaxError.call(this, errors, 'Request was formatted incorrectly.');
}
BadRequestError.prototype = Object.create(AjaxError.prototype);
/**
* @class NotFoundError
* @public
* @extends AjaxError
*/
function NotFoundError(errors) {
AjaxError.call(this, errors, 'Resource was not found.');
}
NotFoundError.prototype = Object.create(AjaxError.prototype);
/**
* @class TimeoutError
* @public
* @extends AjaxError
*/
function TimeoutError() {
AjaxError.call(this, null, 'The ajax operation timed out');
}
TimeoutError.prototype = Object.create(AjaxError.prototype);
/**
* @class AbortError
* @public
* @extends AjaxError
*/
function AbortError() {
AjaxError.call(this, null, 'The ajax operation was aborted');
}
AbortError.prototype = Object.create(AjaxError.prototype);
/**
* @class ConflictError
* @public
* @extends AjaxError
*/
function ConflictError() {
AjaxError.call(this, null, 'The ajax operation failed due to a conflict');
}
ConflictError.prototype = Object.create(AjaxError.prototype);
/**
* @class ServerError
* @public
* @extends AjaxError
*/
function ServerError(errors) {
AjaxError.call(this, errors, 'Request was rejected due to server error');
}
ServerError.prototype = Object.create(AjaxError.prototype);
/**
* Checks if the given error is or inherits from AjaxError
*
* @method isAjaxError
* @public
* @param {Error} error
* @return {Boolean}
*/
function isAjaxError(error) {
return error instanceof AjaxError;
}
/**
* Checks if the given status code or AjaxError object represents an
* unauthorized request error
*
* @method isUnauthorizedError
* @public
* @param {Number | AjaxError} error
* @return {Boolean}
*/
function isUnauthorizedError(error) {
if (isAjaxError(error)) {
return error instanceof UnauthorizedError;
} else {
return error === 401;
}
}
/**
* Checks if the given status code or AjaxError object represents a forbidden
* request error
*
* @method isForbiddenError
* @public
* @param {Number | AjaxError} error
* @return {Boolean}
*/
function isForbiddenError(error) {
if (isAjaxError(error)) {
return error instanceof ForbiddenError;
} else {
return error === 403;
}
}
/**
* Checks if the given status code or AjaxError object represents an invalid
* request error
*
* @method isInvalidError
* @public
* @param {Number | AjaxError} error
* @return {Boolean}
*/
function isInvalidError(error) {
if (isAjaxError(error)) {
return error instanceof InvalidError;
} else {
return error === 422;
}
}
/**
* Checks if the given status code or AjaxError object represents a bad request
* error
*
* @method isBadRequestError
* @public
* @param {Number | AjaxError} error
* @return {Boolean}
*/
function isBadRequestError(error) {
if (isAjaxError(error)) {
return error instanceof BadRequestError;
} else {
return error === 400;
}
}
/**
* Checks if the given status code or AjaxError object represents a
* "not found" error
*
* @method isNotFoundError
* @public
* @param {Number | AjaxError} error
* @return {Boolean}
*/
function isNotFoundError(error) {
if (isAjaxError(error)) {
return error instanceof NotFoundError;
} else {
return error === 404;
}
}
/**
* Checks if the given status code or AjaxError object represents a
* "timeout" error
*
* @method isTimeoutError
* @public
* @param {AjaxError} error
* @return {Boolean}
*/
function isTimeoutError(error) {
return error instanceof TimeoutError;
}
/**
* Checks if the given status code or AjaxError object represents an
* "abort" error
*
* @method isAbortError
* @public
* @param {AjaxError} error
* @return {Boolean}
*/
function isAbortError(error) {
return error instanceof AbortError;
}
/**
* Checks if the given status code or AjaxError object represents a
* conflict error
*
* @method isConflictError
* @public
* @param {Number | AjaxError} error
* @return {Boolean}
*/
function isConflictError(error) {
if (isAjaxError(error)) {
return error instanceof ConflictError;
} else {
return error === 409;
}
}
/**
* Checks if the given status code or AjaxError object represents a server error
*
* @method isServerError
* @public
* @param {Number | AjaxError} error
* @return {Boolean}
*/
function isServerError(error) {
if (isAjaxError(error)) {
return error instanceof ServerError;
} else {
return error >= 500 && error < 600;
}
}
/**
* Checks if the given status code represents a successful request
*
* @method isSuccess
* @public
* @param {Number} status
* @return {Boolean}
*/
function isSuccess(status) {
var s = parseInt(status, 10);
return s >= 200 && s < 300 || s === 304;
}
}); | hoka-plus/p-01-web | tmp/babel-output_path-hOv4KMmE.tmp/ember-ajax/errors.js | JavaScript | mit | 7,481 |
'use strict';
var _index = require('./index');
require('should');
require('should-sinon');
var _sinon = require('sinon');
var sinon = _interopRequireWildcard(_sinon);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
describe('MemoryCache', function () {
it('should be available', function () {
let cache = new _index.MemoryCache();
cache.should.be.Object();
});
it('should be able to add an item in cache', function () {
let cache = new _index.MemoryCache();
(function () {
cache.set('key1', 'value1');
}).should.not.throw();
cache.Size.should.be.exactly(1);
cache._cacheStore.has('key1').should.be.true();
(function () {
cache.set('key2', 'value2', 100);
}).should.not.throw();
cache.Size.should.be.exactly(2);
cache._cacheStore.has('key2').should.be.true();
(function () {
cache.set('key3', 'value3', 100, function (key) {
console.log(key);
});
}).should.not.throw();
cache.Size.should.be.exactly(3);
cache._cacheStore.has('key3').should.be.true();
});
it('should be able get the size of the cache', function () {
let cache = new _index.MemoryCache();
cache.set('key1', 'value1', 25);
cache.set('key2', 'value2');
cache.set('key3', 'value3', 25, function (key) {
console.log(key);
});
cache.Size.should.be.exactly(3);
});
it('should be able to check if cache contains an item', function () {
let cache = new _index.MemoryCache();
cache.set('key1', 'value1', 25);
cache.set('key2', 'value2');
cache.set('key3', 'value3', 25, function (key) {
console.log(key);
});
cache.contains('key1').should.be.true();
cache.contains('key2').should.be.true();
cache.contains('key5').should.not.be.true();
});
it('should be able to retrieve an item from cache stored without a timeout', function (done) {
let cache = new _index.MemoryCache();
cache.set('key1', 'value1');
cache.set('key2', 'value2');
cache.set('key3', 'value3');
cache.get('key2').should.be.exactly('value2');
setTimeout(function () {
cache.get('key2').should.be.exactly('value2');
done();
}, 25);
});
it('should be able to retrieve an item from cache till timeout', function (done) {
let cache = new _index.MemoryCache();
cache.set('key1', 'value1', 40);
cache.set('key2', 'value2', 20);
cache.set('key3', 'value3', 60);
cache.get('key1').should.be.exactly('value1');
setTimeout(function () {
cache.get('key2').should.be.exactly('value2');
done();
}, 18);
});
it('should remove cached items after timeout', function (done) {
let cache = new _index.MemoryCache();
cache.set('key1', 'value1', 40);
cache.set('key2', 'value2', 20);
cache.set('key3', 'value3', 60);
cache.Size.should.be.exactly(3);
setTimeout(function () {
cache.contains('key1').should.be.true();
cache.get('key1').should.be.ok();
cache.contains('key2').should.be.false();
//cache.get('key2').should.not.be.ok();
cache.contains('key3').should.be.true();
cache.get('key3').should.be.ok();
cache.Size.should.be.exactly(2);
done();
}, 21);
});
it('should call the callback when timeout occures', function (done) {
let cache = new _index.MemoryCache(),
callback1 = sinon.spy(),
callback2 = sinon.spy();
cache.set('key1', 'value1', 40, callback1);
cache.set('key2', 'value2', 20, callback2);
cache.set('key3', 'value3', 60);
setTimeout(function () {
callback1.should.not.be.called();
callback2.should.be.calledWith('key2');
done();
}, 25);
});
it('should be able to remove an item from cache', function () {
let cache = new _index.MemoryCache();
cache.set('key1', 'value1', 25);
cache.set('key2', 'value2');
cache.set('key3', 'value3', 25, function (key) {
console.log(key);
});
cache.Size.should.be.exactly(3);
cache.remove('key1');
cache.Size.should.be.exactly(2);
cache.remove('key2');
cache.Size.should.be.exactly(1);
cache.remove('key3');
cache.Size.should.be.exactly(0);
});
it('should be able to clear the cache', function () {
let cache = new _index.MemoryCache();
cache.set('key1', 'value1', 25);
cache.set('key2', 'value2');
cache.set('key3', 'value3', 25, function (key) {
console.log(key);
});
cache.Size.should.be.exactly(3);
cache.clear();
cache.Size.should.be.exactly(0);
});
});
//# sourceMappingURL=test.js.map | subhajitdas/memory-cache | dist/test.js | JavaScript | mit | 5,274 |
'use strict';
module.exports = function (sequelize, Sequelize) {
var TelegramVenue = sequelize.define('telegram_venue', {
id : {
type : Sequelize.INTEGER,
unique : true,
primaryKey : true,
allowNull : false,
autoIncrement: true
},
title : {
type : Sequelize.STRING,
allowNull : false
},
address : {
type : Sequelize.STRING,
allowNull: false
},
foursquare_id: {
type: Sequelize.STRING
}
});
return TelegramVenue;
};
| wlfyit/Vesta-vCore-ORM | models/telegram/venue.js | JavaScript | mit | 550 |
/* global describe, it, expect, before */
/* jshint expr: true */
var fs = require('fs')
, parse = require('../lib/profile').parse;
describe('profile.parse', function() {
describe('example profile', function() {
var profile;
before(function(done) {
fs.readFile('test/data/example.json', 'utf8', function(err, data) {
if (err) { return done(err); }
profile = parse(data);
done();
});
});
it('should parse profile', function() {
expect(profile.id).to.equal('11');
expect(profile.username).to.equal('pixiv');
expect(profile.displayName).to.equal('pixiv事務局');
expect(profile.photos).to.have.length(2);
});
});
});
| pixiv/passport-pixiv | test/profile.test.js | JavaScript | mit | 709 |
/*! React Starter Kit | MIT License | http://www.reactstarterkit.com/ */
import React, { PropTypes, Component } from 'react';
import ChannelSearchSelectorItem from '../ChannelSearchSelectorItem';
class ChannelSearchSelector extends Component {
render() {
var channels = this.props.filteredChannels;
return (
<div className="ChannelSearchSelector">
{
channels.map(function(channel, index) {
return (
<ChannelSearchSelectorItem key={channel.id} channel={channel}/>
)
})
}
</div>
);
}
}
export default ChannelSearchSelector;
| maysale01/react-platform | src/components/ChannelSearchSelector/ChannelSearchSelector.js | JavaScript | mit | 648 |
"use strict";
var helpers = require("../../helpers/helpers");
exports["Asia/Hebron"] = {
"1940" : helpers.makeTestYear("Asia/Hebron", [
["1940-05-31T21:59:59+00:00", "23:59:59", "EET", -120],
["1940-05-31T22:00:00+00:00", "01:00:00", "EEST", -180]
]),
"1942" : helpers.makeTestYear("Asia/Hebron", [
["1942-10-31T20:59:59+00:00", "23:59:59", "EEST", -180],
["1942-10-31T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"1943" : helpers.makeTestYear("Asia/Hebron", [
["1943-03-31T23:59:59+00:00", "01:59:59", "EET", -120],
["1943-04-01T00:00:00+00:00", "03:00:00", "EEST", -180],
["1943-10-31T20:59:59+00:00", "23:59:59", "EEST", -180],
["1943-10-31T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"1944" : helpers.makeTestYear("Asia/Hebron", [
["1944-03-31T21:59:59+00:00", "23:59:59", "EET", -120],
["1944-03-31T22:00:00+00:00", "01:00:00", "EEST", -180],
["1944-10-31T20:59:59+00:00", "23:59:59", "EEST", -180],
["1944-10-31T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"1945" : helpers.makeTestYear("Asia/Hebron", [
["1945-04-15T21:59:59+00:00", "23:59:59", "EET", -120],
["1945-04-15T22:00:00+00:00", "01:00:00", "EEST", -180],
["1945-10-31T22:59:59+00:00", "01:59:59", "EEST", -180],
["1945-10-31T23:00:00+00:00", "01:00:00", "EET", -120]
]),
"1946" : helpers.makeTestYear("Asia/Hebron", [
["1946-04-15T23:59:59+00:00", "01:59:59", "EET", -120],
["1946-04-16T00:00:00+00:00", "03:00:00", "EEST", -180],
["1946-10-31T20:59:59+00:00", "23:59:59", "EEST", -180],
["1946-10-31T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"1957" : helpers.makeTestYear("Asia/Hebron", [
["1957-05-09T21:59:59+00:00", "23:59:59", "EET", -120],
["1957-05-09T22:00:00+00:00", "01:00:00", "EEST", -180],
["1957-09-30T20:59:59+00:00", "23:59:59", "EEST", -180],
["1957-09-30T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"1958" : helpers.makeTestYear("Asia/Hebron", [
["1958-04-30T21:59:59+00:00", "23:59:59", "EET", -120],
["1958-04-30T22:00:00+00:00", "01:00:00", "EEST", -180],
["1958-09-30T20:59:59+00:00", "23:59:59", "EEST", -180],
["1958-09-30T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"1959" : helpers.makeTestYear("Asia/Hebron", [
["1959-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1959-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1959-09-29T23:59:59+00:00", "02:59:59", "EEST", -180],
["1959-09-30T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1960" : helpers.makeTestYear("Asia/Hebron", [
["1960-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1960-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1960-09-29T23:59:59+00:00", "02:59:59", "EEST", -180],
["1960-09-30T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1961" : helpers.makeTestYear("Asia/Hebron", [
["1961-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1961-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1961-09-29T23:59:59+00:00", "02:59:59", "EEST", -180],
["1961-09-30T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1962" : helpers.makeTestYear("Asia/Hebron", [
["1962-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1962-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1962-09-29T23:59:59+00:00", "02:59:59", "EEST", -180],
["1962-09-30T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1963" : helpers.makeTestYear("Asia/Hebron", [
["1963-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1963-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1963-09-29T23:59:59+00:00", "02:59:59", "EEST", -180],
["1963-09-30T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1964" : helpers.makeTestYear("Asia/Hebron", [
["1964-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1964-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1964-09-29T23:59:59+00:00", "02:59:59", "EEST", -180],
["1964-09-30T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1965" : helpers.makeTestYear("Asia/Hebron", [
["1965-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1965-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1965-09-29T23:59:59+00:00", "02:59:59", "EEST", -180],
["1965-09-30T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1966" : helpers.makeTestYear("Asia/Hebron", [
["1966-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1966-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1966-09-30T23:59:59+00:00", "02:59:59", "EEST", -180],
["1966-10-01T00:00:00+00:00", "02:00:00", "EET", -120]
]),
"1967" : helpers.makeTestYear("Asia/Hebron", [
["1967-04-30T22:59:59+00:00", "00:59:59", "EET", -120],
["1967-04-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["1967-06-04T20:59:59+00:00", "23:59:59", "EEST", -180],
["1967-06-04T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1974" : helpers.makeTestYear("Asia/Hebron", [
["1974-07-06T21:59:59+00:00", "23:59:59", "IST", -120],
["1974-07-06T22:00:00+00:00", "01:00:00", "IDT", -180],
["1974-10-12T20:59:59+00:00", "23:59:59", "IDT", -180],
["1974-10-12T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1975" : helpers.makeTestYear("Asia/Hebron", [
["1975-04-19T21:59:59+00:00", "23:59:59", "IST", -120],
["1975-04-19T22:00:00+00:00", "01:00:00", "IDT", -180],
["1975-08-30T20:59:59+00:00", "23:59:59", "IDT", -180],
["1975-08-30T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1985" : helpers.makeTestYear("Asia/Hebron", [
["1985-04-13T21:59:59+00:00", "23:59:59", "IST", -120],
["1985-04-13T22:00:00+00:00", "01:00:00", "IDT", -180],
["1985-09-14T20:59:59+00:00", "23:59:59", "IDT", -180],
["1985-09-14T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1986" : helpers.makeTestYear("Asia/Hebron", [
["1986-05-17T21:59:59+00:00", "23:59:59", "IST", -120],
["1986-05-17T22:00:00+00:00", "01:00:00", "IDT", -180],
["1986-09-06T20:59:59+00:00", "23:59:59", "IDT", -180],
["1986-09-06T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1987" : helpers.makeTestYear("Asia/Hebron", [
["1987-04-14T21:59:59+00:00", "23:59:59", "IST", -120],
["1987-04-14T22:00:00+00:00", "01:00:00", "IDT", -180],
["1987-09-12T20:59:59+00:00", "23:59:59", "IDT", -180],
["1987-09-12T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1988" : helpers.makeTestYear("Asia/Hebron", [
["1988-04-09T21:59:59+00:00", "23:59:59", "IST", -120],
["1988-04-09T22:00:00+00:00", "01:00:00", "IDT", -180],
["1988-09-03T20:59:59+00:00", "23:59:59", "IDT", -180],
["1988-09-03T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1989" : helpers.makeTestYear("Asia/Hebron", [
["1989-04-29T21:59:59+00:00", "23:59:59", "IST", -120],
["1989-04-29T22:00:00+00:00", "01:00:00", "IDT", -180],
["1989-09-02T20:59:59+00:00", "23:59:59", "IDT", -180],
["1989-09-02T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1990" : helpers.makeTestYear("Asia/Hebron", [
["1990-03-24T21:59:59+00:00", "23:59:59", "IST", -120],
["1990-03-24T22:00:00+00:00", "01:00:00", "IDT", -180],
["1990-08-25T20:59:59+00:00", "23:59:59", "IDT", -180],
["1990-08-25T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1991" : helpers.makeTestYear("Asia/Hebron", [
["1991-03-23T21:59:59+00:00", "23:59:59", "IST", -120],
["1991-03-23T22:00:00+00:00", "01:00:00", "IDT", -180],
["1991-08-31T20:59:59+00:00", "23:59:59", "IDT", -180],
["1991-08-31T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1992" : helpers.makeTestYear("Asia/Hebron", [
["1992-03-28T21:59:59+00:00", "23:59:59", "IST", -120],
["1992-03-28T22:00:00+00:00", "01:00:00", "IDT", -180],
["1992-09-05T20:59:59+00:00", "23:59:59", "IDT", -180],
["1992-09-05T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1993" : helpers.makeTestYear("Asia/Hebron", [
["1993-04-01T21:59:59+00:00", "23:59:59", "IST", -120],
["1993-04-01T22:00:00+00:00", "01:00:00", "IDT", -180],
["1993-09-04T20:59:59+00:00", "23:59:59", "IDT", -180],
["1993-09-04T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1994" : helpers.makeTestYear("Asia/Hebron", [
["1994-03-31T21:59:59+00:00", "23:59:59", "IST", -120],
["1994-03-31T22:00:00+00:00", "01:00:00", "IDT", -180],
["1994-08-27T20:59:59+00:00", "23:59:59", "IDT", -180],
["1994-08-27T21:00:00+00:00", "23:00:00", "IST", -120]
]),
"1995" : helpers.makeTestYear("Asia/Hebron", [
["1995-03-30T21:59:59+00:00", "23:59:59", "IST", -120],
["1995-03-30T22:00:00+00:00", "01:00:00", "IDT", -180],
["1995-09-02T20:59:59+00:00", "23:59:59", "IDT", -180],
["1995-09-02T21:00:00+00:00", "23:00:00", "IST", -120],
["1995-12-31T21:59:59+00:00", "23:59:59", "IST", -120],
["1995-12-31T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"1996" : helpers.makeTestYear("Asia/Hebron", [
["1996-04-04T21:59:59+00:00", "23:59:59", "EET", -120],
["1996-04-04T22:00:00+00:00", "01:00:00", "EEST", -180],
["1996-09-19T21:59:59+00:00", "00:59:59", "EEST", -180],
["1996-09-19T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"1997" : helpers.makeTestYear("Asia/Hebron", [
["1997-04-03T21:59:59+00:00", "23:59:59", "EET", -120],
["1997-04-03T22:00:00+00:00", "01:00:00", "EEST", -180],
["1997-09-18T21:59:59+00:00", "00:59:59", "EEST", -180],
["1997-09-18T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"1998" : helpers.makeTestYear("Asia/Hebron", [
["1998-04-02T21:59:59+00:00", "23:59:59", "EET", -120],
["1998-04-02T22:00:00+00:00", "01:00:00", "EEST", -180],
["1998-09-17T21:59:59+00:00", "00:59:59", "EEST", -180],
["1998-09-17T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"1999" : helpers.makeTestYear("Asia/Hebron", [
["1999-04-15T21:59:59+00:00", "23:59:59", "EET", -120],
["1999-04-15T22:00:00+00:00", "01:00:00", "EEST", -180],
["1999-10-14T20:59:59+00:00", "23:59:59", "EEST", -180],
["1999-10-14T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2000" : helpers.makeTestYear("Asia/Hebron", [
["2000-04-20T21:59:59+00:00", "23:59:59", "EET", -120],
["2000-04-20T22:00:00+00:00", "01:00:00", "EEST", -180],
["2000-10-19T20:59:59+00:00", "23:59:59", "EEST", -180],
["2000-10-19T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2001" : helpers.makeTestYear("Asia/Hebron", [
["2001-04-19T21:59:59+00:00", "23:59:59", "EET", -120],
["2001-04-19T22:00:00+00:00", "01:00:00", "EEST", -180],
["2001-10-18T20:59:59+00:00", "23:59:59", "EEST", -180],
["2001-10-18T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2002" : helpers.makeTestYear("Asia/Hebron", [
["2002-04-18T21:59:59+00:00", "23:59:59", "EET", -120],
["2002-04-18T22:00:00+00:00", "01:00:00", "EEST", -180],
["2002-10-17T20:59:59+00:00", "23:59:59", "EEST", -180],
["2002-10-17T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2003" : helpers.makeTestYear("Asia/Hebron", [
["2003-04-17T21:59:59+00:00", "23:59:59", "EET", -120],
["2003-04-17T22:00:00+00:00", "01:00:00", "EEST", -180],
["2003-10-16T20:59:59+00:00", "23:59:59", "EEST", -180],
["2003-10-16T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2004" : helpers.makeTestYear("Asia/Hebron", [
["2004-04-15T21:59:59+00:00", "23:59:59", "EET", -120],
["2004-04-15T22:00:00+00:00", "01:00:00", "EEST", -180],
["2004-09-30T21:59:59+00:00", "00:59:59", "EEST", -180],
["2004-09-30T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2005" : helpers.makeTestYear("Asia/Hebron", [
["2005-04-14T21:59:59+00:00", "23:59:59", "EET", -120],
["2005-04-14T22:00:00+00:00", "01:00:00", "EEST", -180],
["2005-10-03T22:59:59+00:00", "01:59:59", "EEST", -180],
["2005-10-03T23:00:00+00:00", "01:00:00", "EET", -120]
]),
"2006" : helpers.makeTestYear("Asia/Hebron", [
["2006-03-31T21:59:59+00:00", "23:59:59", "EET", -120],
["2006-03-31T22:00:00+00:00", "01:00:00", "EEST", -180],
["2006-09-21T20:59:59+00:00", "23:59:59", "EEST", -180],
["2006-09-21T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2007" : helpers.makeTestYear("Asia/Hebron", [
["2007-03-31T21:59:59+00:00", "23:59:59", "EET", -120],
["2007-03-31T22:00:00+00:00", "01:00:00", "EEST", -180],
["2007-09-12T22:59:59+00:00", "01:59:59", "EEST", -180],
["2007-09-12T23:00:00+00:00", "01:00:00", "EET", -120]
]),
"2008" : helpers.makeTestYear("Asia/Hebron", [
["2008-03-27T21:59:59+00:00", "23:59:59", "EET", -120],
["2008-03-27T22:00:00+00:00", "01:00:00", "EEST", -180],
["2008-08-31T20:59:59+00:00", "23:59:59", "EEST", -180],
["2008-08-31T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2009" : helpers.makeTestYear("Asia/Hebron", [
["2009-03-26T21:59:59+00:00", "23:59:59", "EET", -120],
["2009-03-26T22:00:00+00:00", "01:00:00", "EEST", -180],
["2009-09-03T21:59:59+00:00", "00:59:59", "EEST", -180],
["2009-09-03T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2010" : helpers.makeTestYear("Asia/Hebron", [
["2010-03-25T21:59:59+00:00", "23:59:59", "EET", -120],
["2010-03-25T22:00:00+00:00", "01:00:00", "EEST", -180],
["2010-08-10T20:59:59+00:00", "23:59:59", "EEST", -180],
["2010-08-10T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2011" : helpers.makeTestYear("Asia/Hebron", [
["2011-03-31T22:00:59+00:00", "00:00:59", "EET", -120],
["2011-03-31T22:01:00+00:00", "01:01:00", "EEST", -180],
["2011-07-31T20:59:59+00:00", "23:59:59", "EEST", -180],
["2011-07-31T21:00:00+00:00", "23:00:00", "EET", -120],
["2011-08-29T21:59:59+00:00", "23:59:59", "EET", -120],
["2011-08-29T22:00:00+00:00", "01:00:00", "EEST", -180],
["2011-09-29T20:59:59+00:00", "23:59:59", "EEST", -180],
["2011-09-29T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2012" : helpers.makeTestYear("Asia/Hebron", [
["2012-03-29T21:59:59+00:00", "23:59:59", "EET", -120],
["2012-03-29T22:00:00+00:00", "01:00:00", "EEST", -180],
["2012-09-20T21:59:59+00:00", "00:59:59", "EEST", -180],
["2012-09-20T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2013" : helpers.makeTestYear("Asia/Hebron", [
["2013-03-28T21:59:59+00:00", "23:59:59", "EET", -120],
["2013-03-28T22:00:00+00:00", "01:00:00", "EEST", -180],
["2013-09-26T20:59:59+00:00", "23:59:59", "EEST", -180],
["2013-09-26T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2014" : helpers.makeTestYear("Asia/Hebron", [
["2014-03-27T21:59:59+00:00", "23:59:59", "EET", -120],
["2014-03-27T22:00:00+00:00", "01:00:00", "EEST", -180],
["2014-10-23T20:59:59+00:00", "23:59:59", "EEST", -180],
["2014-10-23T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2015" : helpers.makeTestYear("Asia/Hebron", [
["2015-03-27T21:59:59+00:00", "23:59:59", "EET", -120],
["2015-03-27T22:00:00+00:00", "01:00:00", "EEST", -180],
["2015-10-22T20:59:59+00:00", "23:59:59", "EEST", -180],
["2015-10-22T21:00:00+00:00", "23:00:00", "EET", -120]
]),
"2016" : helpers.makeTestYear("Asia/Hebron", [
["2016-03-25T22:59:59+00:00", "00:59:59", "EET", -120],
["2016-03-25T23:00:00+00:00", "02:00:00", "EEST", -180],
["2016-10-28T21:59:59+00:00", "00:59:59", "EEST", -180],
["2016-10-28T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2017" : helpers.makeTestYear("Asia/Hebron", [
["2017-03-24T22:59:59+00:00", "00:59:59", "EET", -120],
["2017-03-24T23:00:00+00:00", "02:00:00", "EEST", -180],
["2017-10-27T21:59:59+00:00", "00:59:59", "EEST", -180],
["2017-10-27T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2018" : helpers.makeTestYear("Asia/Hebron", [
["2018-03-30T22:59:59+00:00", "00:59:59", "EET", -120],
["2018-03-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["2018-10-26T21:59:59+00:00", "00:59:59", "EEST", -180],
["2018-10-26T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2019" : helpers.makeTestYear("Asia/Hebron", [
["2019-03-29T22:59:59+00:00", "00:59:59", "EET", -120],
["2019-03-29T23:00:00+00:00", "02:00:00", "EEST", -180],
["2019-10-25T21:59:59+00:00", "00:59:59", "EEST", -180],
["2019-10-25T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2020" : helpers.makeTestYear("Asia/Hebron", [
["2020-03-27T22:59:59+00:00", "00:59:59", "EET", -120],
["2020-03-27T23:00:00+00:00", "02:00:00", "EEST", -180],
["2020-10-30T21:59:59+00:00", "00:59:59", "EEST", -180],
["2020-10-30T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2021" : helpers.makeTestYear("Asia/Hebron", [
["2021-03-26T22:59:59+00:00", "00:59:59", "EET", -120],
["2021-03-26T23:00:00+00:00", "02:00:00", "EEST", -180],
["2021-10-29T21:59:59+00:00", "00:59:59", "EEST", -180],
["2021-10-29T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2022" : helpers.makeTestYear("Asia/Hebron", [
["2022-03-25T22:59:59+00:00", "00:59:59", "EET", -120],
["2022-03-25T23:00:00+00:00", "02:00:00", "EEST", -180],
["2022-10-28T21:59:59+00:00", "00:59:59", "EEST", -180],
["2022-10-28T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2023" : helpers.makeTestYear("Asia/Hebron", [
["2023-03-24T22:59:59+00:00", "00:59:59", "EET", -120],
["2023-03-24T23:00:00+00:00", "02:00:00", "EEST", -180],
["2023-10-27T21:59:59+00:00", "00:59:59", "EEST", -180],
["2023-10-27T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2024" : helpers.makeTestYear("Asia/Hebron", [
["2024-03-29T22:59:59+00:00", "00:59:59", "EET", -120],
["2024-03-29T23:00:00+00:00", "02:00:00", "EEST", -180],
["2024-10-25T21:59:59+00:00", "00:59:59", "EEST", -180],
["2024-10-25T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2025" : helpers.makeTestYear("Asia/Hebron", [
["2025-03-28T22:59:59+00:00", "00:59:59", "EET", -120],
["2025-03-28T23:00:00+00:00", "02:00:00", "EEST", -180],
["2025-10-24T21:59:59+00:00", "00:59:59", "EEST", -180],
["2025-10-24T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2026" : helpers.makeTestYear("Asia/Hebron", [
["2026-03-27T22:59:59+00:00", "00:59:59", "EET", -120],
["2026-03-27T23:00:00+00:00", "02:00:00", "EEST", -180],
["2026-10-30T21:59:59+00:00", "00:59:59", "EEST", -180],
["2026-10-30T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2027" : helpers.makeTestYear("Asia/Hebron", [
["2027-03-26T22:59:59+00:00", "00:59:59", "EET", -120],
["2027-03-26T23:00:00+00:00", "02:00:00", "EEST", -180],
["2027-10-29T21:59:59+00:00", "00:59:59", "EEST", -180],
["2027-10-29T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2028" : helpers.makeTestYear("Asia/Hebron", [
["2028-03-24T22:59:59+00:00", "00:59:59", "EET", -120],
["2028-03-24T23:00:00+00:00", "02:00:00", "EEST", -180],
["2028-10-27T21:59:59+00:00", "00:59:59", "EEST", -180],
["2028-10-27T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2029" : helpers.makeTestYear("Asia/Hebron", [
["2029-03-30T22:59:59+00:00", "00:59:59", "EET", -120],
["2029-03-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["2029-10-26T21:59:59+00:00", "00:59:59", "EEST", -180],
["2029-10-26T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2030" : helpers.makeTestYear("Asia/Hebron", [
["2030-03-29T22:59:59+00:00", "00:59:59", "EET", -120],
["2030-03-29T23:00:00+00:00", "02:00:00", "EEST", -180],
["2030-10-25T21:59:59+00:00", "00:59:59", "EEST", -180],
["2030-10-25T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2031" : helpers.makeTestYear("Asia/Hebron", [
["2031-03-28T22:59:59+00:00", "00:59:59", "EET", -120],
["2031-03-28T23:00:00+00:00", "02:00:00", "EEST", -180],
["2031-10-24T21:59:59+00:00", "00:59:59", "EEST", -180],
["2031-10-24T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2032" : helpers.makeTestYear("Asia/Hebron", [
["2032-03-26T22:59:59+00:00", "00:59:59", "EET", -120],
["2032-03-26T23:00:00+00:00", "02:00:00", "EEST", -180],
["2032-10-29T21:59:59+00:00", "00:59:59", "EEST", -180],
["2032-10-29T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2033" : helpers.makeTestYear("Asia/Hebron", [
["2033-03-25T22:59:59+00:00", "00:59:59", "EET", -120],
["2033-03-25T23:00:00+00:00", "02:00:00", "EEST", -180],
["2033-10-28T21:59:59+00:00", "00:59:59", "EEST", -180],
["2033-10-28T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2034" : helpers.makeTestYear("Asia/Hebron", [
["2034-03-24T22:59:59+00:00", "00:59:59", "EET", -120],
["2034-03-24T23:00:00+00:00", "02:00:00", "EEST", -180],
["2034-10-27T21:59:59+00:00", "00:59:59", "EEST", -180],
["2034-10-27T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2035" : helpers.makeTestYear("Asia/Hebron", [
["2035-03-30T22:59:59+00:00", "00:59:59", "EET", -120],
["2035-03-30T23:00:00+00:00", "02:00:00", "EEST", -180],
["2035-10-26T21:59:59+00:00", "00:59:59", "EEST", -180],
["2035-10-26T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2036" : helpers.makeTestYear("Asia/Hebron", [
["2036-03-28T22:59:59+00:00", "00:59:59", "EET", -120],
["2036-03-28T23:00:00+00:00", "02:00:00", "EEST", -180],
["2036-10-24T21:59:59+00:00", "00:59:59", "EEST", -180],
["2036-10-24T22:00:00+00:00", "00:00:00", "EET", -120]
]),
"2037" : helpers.makeTestYear("Asia/Hebron", [
["2037-03-27T22:59:59+00:00", "00:59:59", "EET", -120],
["2037-03-27T23:00:00+00:00", "02:00:00", "EEST", -180],
["2037-10-30T21:59:59+00:00", "00:59:59", "EEST", -180],
["2037-10-30T22:00:00+00:00", "00:00:00", "EET", -120]
])
}; | adones/dubid | assets/libraries/moment-timezone/tests/zones/asia/hebron.js | JavaScript | mit | 20,845 |
// Copyright (c) 2012 Titanium I.T. LLC. All rights reserved. See LICENSE.txt for details.
/*global desc, task, jake, fail, complete, directory, require, console, process */
(function() {
"use strict";
var REQUIRED_BROWSERS = [
// "IE 8.0 (Windows)", // NOTE: IE 8 is not supported. See the readme for details.
// "IE 9.0 (Windows)",
// "Firefox 20.0 (Mac)",
// "Chrome 26.0 (Mac)",
// "Safari 6.0 (Mac)",
// "Safari 6.0 (iOS)"
];
var lint = require("./build/util/lint_runner.js");
var karma = require("./build/util/karma_runner.js");
desc("Lint and test");
task("default", ["lint", "test"], function() {
console.log("\n\nOK");
});
desc("Start Karma server -- run this first");
task("karma", function() {
karma.serve(complete, fail);
}, {async: true});
desc("Lint everything");
task("lint", [], function() {
var passed = lint.validateFileList(browserFilesToLint(), browserLintOptions(), {});
if (!passed) fail("Lint failed");
});
desc("Test everything");
task("test", function() {
karma.runTests(REQUIRED_BROWSERS, complete, fail);
}, {async: true});
function browserFilesToLint() {
var files = new jake.FileList();
files.include("src/*.js");
return files.toArray();
}
function globalLintOptions() {
return {
bitwise: true,
curly: false,
eqeqeq: true,
forin: true,
immed: true,
latedef: false,
newcap: true,
noarg: true,
noempty: true,
nonew: true,
regexp: true,
undef: true,
strict: true,
trailing: true
};
}
function browserLintOptions() {
var options = globalLintOptions();
options.browser = true;
return options;
}
}()); | jamesshore/agile2013 | Jakefile.js | JavaScript | mit | 1,632 |
/*
global describe, beforeEach, afterEach, it, expect
*/
'use strict'
let Model = require('../../src/js/PledgeYourSupport')
var sinon = require('sinon')
var validation = require('../../src/js/validation')
describe('Pledge Your Support', () => {
var sut
var validationInitStub
var validationGetGroupStub
var validationGroup
beforeEach(() => {
validationInitStub = sinon.stub(validation, 'initialise')
validationGroup = {
'validation': 'group'
}
validationGetGroupStub = sinon.stub(validation, 'getValidationGroup').returns(validationGroup)
sut = new Model()
})
afterEach(() => {
validation.initialise.restore()
validation.getValidationGroup.restore()
})
it('- Should set Section 1 as active', () => {
expect(sut.section1.isActive()).toBeTruthy()
})
it('- Should set Section 2 as inactive', () => {
expect(sut.section2.isActive()).toBeFalsy()
})
it('- Should set Section 3 as inactive', () => {
expect(sut.section3.isActive()).toBeFalsy()
})
it('- Should initialise validation', () => {
expect(validationInitStub.calledOnce).toBeTruthy()
})
it('- Should set validation group with form model', () => {
expect(validationGetGroupStub.calledOnce).toBeTruthy()
})
})
| StreetSupport/manchester-charter | spec/pledge-your-support/initialiseSpec.js | JavaScript | mit | 1,261 |
/*eslint-env browser*/
"use strict";
var System = require("./system");
var URL = require("./url");
var getParams = require("./script-params");
module.exports = boot;
function boot(params) {
params = params || getParams("boot.js");
var moduleLocation = URL.resolve(window.location, ".");
var systemLocation = URL.resolve(window.location, params.package || ".");
var abs = "";
if (moduleLocation.lastIndexOf(systemLocation, 0) === 0) {
abs = moduleLocation.slice(systemLocation.length);
}
var rel = params.import || "";
return System.load(systemLocation, {
browser: true
}).then(function onSystemLoaded(system) {
window.system = system;
return system.import(rel, abs);
});
}
if (require.main === module) {
boot().done();
}
| mohammed52/door-quote-automator | node_modules/system/boot-entry.js | JavaScript | mit | 803 |
import { handleActions } from 'redux-actions';
import update from 'immutability-helper';
import { merge, union, difference } from 'lodash';
import quiz from 'features/quiz/actions';
import randomInsert from 'common/utils/randomInsert';
import { WRAP_UP_STARTING_COUNT } from './constants';
export const initialQuizSessionState = {
category: '',
wrapUp: { active: false, count: 10 },
synonymModalOpen: false,
current: {},
queue: [],
correct: [],
incorrect: [],
complete: [],
};
const setCategory = (state, { payload }) => update(state, {
category: { $set: payload },
});
const setSynonymModalOpen = (state, { payload }) => update(state, {
synonymModalOpen: { $set: payload },
});
export const getWrapUpItems = (state) => {
let needsReview = difference(state.incorrect, state.complete);
if (needsReview.length < WRAP_UP_STARTING_COUNT) {
needsReview = [...needsReview, ...difference(state.queue, needsReview)].slice(
0,
WRAP_UP_STARTING_COUNT,
);
}
return needsReview;
};
const toggleWrapUp = (state) => {
let { queue } = state;
let count = WRAP_UP_STARTING_COUNT;
const active = !state.wrapUp.active;
if (active) {
queue = getWrapUpItems(state);
count = queue.length;
}
return update(state, {
wrapUp: {
active: { $set: active },
count: { $set: count },
},
queue: { $set: queue },
});
};
const decrementWrapUp = (state) => state.wrapUp.active
? update(state, {
wrapUp: { count: { $set: Math.max(state.wrapUp.count - 1, 0) } },
})
: state;
const replaceCurrent = (state, { payload }) => update(state, {
current: { $set: payload },
queue: { $set: difference(state.queue, [state.current.id]) },
});
const mergeCurrent = (state, { payload }) => update(state, {
current: { $set: merge({}, state.current, payload) },
});
const rotateCurrent = (state, { payload }) => update(state, {
current: { $set: payload.newCurrent },
queue: {
$set: randomInsert(difference(state.queue, [payload.currentId]), payload.currentId),
},
});
const addIdToCorrect = (state, { payload }) => update(state, {
correct: { $set: union(state.correct, [payload]) },
});
const addIdToIncorrect = (state, { payload }) => update(state, {
incorrect: { $set: union(state.incorrect, [payload]) },
});
const addIdToComplete = (state, { payload }) => update(state, {
complete: { $set: union(state.complete, [payload]) },
});
const removeIdFromQueue = (state, { payload }) => update(state, {
queue: { $set: difference(state.queue, [payload]) },
});
const mergeQueue = (state, { payload }) => update(state, {
queue: {
$set: union(state.queue, difference(payload.reviewIds, [state.current.id], state.complete)),
},
});
const clearQueue = (state) => update(state, {
queue: {
$set: [],
},
});
export const quizSessionReducer = handleActions(
{
[quiz.session.setCategory]: setCategory,
// TODO: move to synonyms or info?
[quiz.session.setSynonymModal]: setSynonymModalOpen,
[quiz.session.wrapUp.toggle]: toggleWrapUp,
[quiz.session.wrapUp.decrement]: decrementWrapUp,
[quiz.session.queue.load.success]: mergeQueue,
[quiz.session.queue.remove]: removeIdFromQueue,
[quiz.session.queue.clear]: clearQueue,
[quiz.session.current.replace]: replaceCurrent,
[quiz.session.current.update]: mergeCurrent,
[quiz.session.current.rotate]: rotateCurrent,
[quiz.session.addCorrect]: addIdToCorrect,
[quiz.session.addIncorrect]: addIdToIncorrect,
[quiz.session.addComplete]: addIdToComplete,
[quiz.session.reset]: (state) => ({ ...initialQuizSessionState, category: state.category }),
},
initialQuizSessionState,
);
export default quizSessionReducer;
| Kaniwani/KW-Frontend | app/features/quiz/QuizSession/reducer.js | JavaScript | mit | 3,716 |
/*!
* Angular Material Design
* https://github.com/angular/material
* @license MIT
* v0.10.1-master-e26a275
*/
goog.provide('ng.material.components.slider');
goog.require('ng.material.core');
/**
* @ngdoc module
* @name material.components.slider
*/
angular.module('material.components.slider', [
'material.core'
])
.directive('mdSlider', SliderDirective);
/**
* @ngdoc directive
* @name mdSlider
* @module material.components.slider
* @restrict E
* @description
* The `<md-slider>` component allows the user to choose from a range of
* values.
*
* As per the [material design spec](http://www.google.com/design/spec/style/color.html#color-ui-color-application)
* the slider is in the accent color by default. The primary color palette may be used with
* the `md-primary` class.
*
* It has two modes: 'normal' mode, where the user slides between a wide range
* of values, and 'discrete' mode, where the user slides between only a few
* select values.
*
* To enable discrete mode, add the `md-discrete` attribute to a slider,
* and use the `step` attribute to change the distance between
* values the user is allowed to pick.
*
* @usage
* <h4>Normal Mode</h4>
* <hljs lang="html">
* <md-slider ng-model="myValue" min="5" max="500">
* </md-slider>
* </hljs>
* <h4>Discrete Mode</h4>
* <hljs lang="html">
* <md-slider md-discrete ng-model="myDiscreteValue" step="10" min="10" max="130">
* </md-slider>
* </hljs>
*
* @param {boolean=} md-discrete Whether to enable discrete mode.
* @param {number=} step The distance between values the user is allowed to pick. Default 1.
* @param {number=} min The minimum value the user is allowed to pick. Default 0.
* @param {number=} max The maximum value the user is allowed to pick. Default 100.
*/
function SliderDirective($$rAF, $window, $mdAria, $mdUtil, $mdConstant, $mdTheming, $mdGesture, $parse, $log) {
return {
scope: {},
require: '?ngModel',
template:
'<div class="md-slider-wrapper">\
<div class="md-track-container">\
<div class="md-track"></div>\
<div class="md-track md-track-fill"></div>\
<div class="md-track-ticks"></div>\
</div>\
<div class="md-thumb-container">\
<div class="md-thumb"></div>\
<div class="md-focus-thumb"></div>\
<div class="md-focus-ring"></div>\
<div class="md-sign">\
<span class="md-thumb-text"></span>\
</div>\
<div class="md-disabled-thumb"></div>\
</div>\
</div>',
compile: compile
};
// **********************************************************
// Private Methods
// **********************************************************
function compile (tElement, tAttrs) {
tElement.attr({
tabIndex: 0,
role: 'slider'
});
$mdAria.expect(tElement, 'aria-label');
return postLink;
}
function postLink(scope, element, attr, ngModelCtrl) {
$mdTheming(element);
ngModelCtrl = ngModelCtrl || {
// Mock ngModelController if it doesn't exist to give us
// the minimum functionality needed
$setViewValue: function(val) {
this.$viewValue = val;
this.$viewChangeListeners.forEach(function(cb) { cb(); });
},
$parsers: [],
$formatters: [],
$viewChangeListeners: []
};
var isDisabledParsed = attr.ngDisabled && $parse(attr.ngDisabled);
var isDisabledGetter = isDisabledParsed ?
function() { return isDisabledParsed(scope.$parent); } :
angular.noop;
var thumb = angular.element(element[0].querySelector('.md-thumb'));
var thumbText = angular.element(element[0].querySelector('.md-thumb-text'));
var thumbContainer = thumb.parent();
var trackContainer = angular.element(element[0].querySelector('.md-track-container'));
var activeTrack = angular.element(element[0].querySelector('.md-track-fill'));
var tickContainer = angular.element(element[0].querySelector('.md-track-ticks'));
var throttledRefreshDimensions = $mdUtil.throttle(refreshSliderDimensions, 5000);
// Default values, overridable by attrs
angular.isDefined(attr.min) ? attr.$observe('min', updateMin) : updateMin(0);
angular.isDefined(attr.max) ? attr.$observe('max', updateMax) : updateMax(100);
angular.isDefined(attr.step)? attr.$observe('step', updateStep) : updateStep(1);
// We have to manually stop the $watch on ngDisabled because it exists
// on the parent scope, and won't be automatically destroyed when
// the component is destroyed.
var stopDisabledWatch = angular.noop;
if (attr.ngDisabled) {
stopDisabledWatch = scope.$parent.$watch(attr.ngDisabled, updateAriaDisabled);
}
$mdGesture.register(element, 'drag');
element
.on('keydown', keydownListener)
.on('$md.pressdown', onPressDown)
.on('$md.pressup', onPressUp)
.on('$md.dragstart', onDragStart)
.on('$md.drag', onDrag)
.on('$md.dragend', onDragEnd);
// On resize, recalculate the slider's dimensions and re-render
function updateAll() {
refreshSliderDimensions();
ngModelRender();
redrawTicks();
}
setTimeout(updateAll);
var debouncedUpdateAll = $$rAF.throttle(updateAll);
angular.element($window).on('resize', debouncedUpdateAll);
scope.$on('$destroy', function() {
angular.element($window).off('resize', debouncedUpdateAll);
stopDisabledWatch();
});
ngModelCtrl.$render = ngModelRender;
ngModelCtrl.$viewChangeListeners.push(ngModelRender);
ngModelCtrl.$formatters.push(minMaxValidator);
ngModelCtrl.$formatters.push(stepValidator);
/**
* Attributes
*/
var min;
var max;
var step;
function updateMin(value) {
min = parseFloat(value);
element.attr('aria-valuemin', value);
updateAll();
}
function updateMax(value) {
max = parseFloat(value);
element.attr('aria-valuemax', value);
updateAll();
}
function updateStep(value) {
step = parseFloat(value);
redrawTicks();
}
function updateAriaDisabled(isDisabled) {
element.attr('aria-disabled', !!isDisabled);
}
// Draw the ticks with canvas.
// The alternative to drawing ticks with canvas is to draw one element for each tick,
// which could quickly become a performance bottleneck.
var tickCanvas, tickCtx;
function redrawTicks() {
if (!angular.isDefined(attr.mdDiscrete)) return;
if ( angular.isUndefined(step) ) return;
if ( step <= 0 ) {
var msg = 'Slider step value must be greater than zero when in discrete mode';
$log.error(msg);
throw new Error(msg);
}
var numSteps = Math.floor( (max - min) / step );
if (!tickCanvas) {
tickCanvas = angular.element('<canvas style="position:absolute;">');
tickContainer.append(tickCanvas);
var trackTicksStyle = $window.getComputedStyle(tickContainer[0]);
tickCtx = tickCanvas[0].getContext('2d');
tickCtx.fillStyle = trackTicksStyle.backgroundColor || 'black';
}
var dimensions = getSliderDimensions();
tickCanvas[0].width = dimensions.width;
tickCanvas[0].height = dimensions.height;
var distance;
for (var i = 0; i <= numSteps; i++) {
distance = Math.floor(dimensions.width * (i / numSteps));
tickCtx.fillRect(distance - 1, 0, 2, dimensions.height);
}
}
/**
* Refreshing Dimensions
*/
var sliderDimensions = {};
refreshSliderDimensions();
function refreshSliderDimensions() {
sliderDimensions = trackContainer[0].getBoundingClientRect();
}
function getSliderDimensions() {
throttledRefreshDimensions();
return sliderDimensions;
}
/**
* left/right arrow listener
*/
function keydownListener(ev) {
if(element[0].hasAttribute('disabled')) {
return;
}
var changeAmount;
if (ev.keyCode === $mdConstant.KEY_CODE.LEFT_ARROW) {
changeAmount = -step;
} else if (ev.keyCode === $mdConstant.KEY_CODE.RIGHT_ARROW) {
changeAmount = step;
}
if (changeAmount) {
if (ev.metaKey || ev.ctrlKey || ev.altKey) {
changeAmount *= 4;
}
ev.preventDefault();
ev.stopPropagation();
scope.$evalAsync(function() {
setModelValue(ngModelCtrl.$viewValue + changeAmount);
});
}
}
/**
* ngModel setters and validators
*/
function setModelValue(value) {
ngModelCtrl.$setViewValue( minMaxValidator(stepValidator(value)) );
}
function ngModelRender() {
if (isNaN(ngModelCtrl.$viewValue)) {
ngModelCtrl.$viewValue = ngModelCtrl.$modelValue;
}
var percent = (ngModelCtrl.$viewValue - min) / (max - min);
scope.modelValue = ngModelCtrl.$viewValue;
element.attr('aria-valuenow', ngModelCtrl.$viewValue);
setSliderPercent(percent);
thumbText.text( ngModelCtrl.$viewValue );
}
function minMaxValidator(value) {
if (angular.isNumber(value)) {
return Math.max(min, Math.min(max, value));
}
}
function stepValidator(value) {
if (angular.isNumber(value)) {
var formattedValue = (Math.round(value / step) * step);
// Format to 3 digits after the decimal point - fixes #2015.
return (Math.round(formattedValue * 1000) / 1000);
}
}
/**
* @param percent 0-1
*/
function setSliderPercent(percent) {
activeTrack.css('width', (percent * 100) + '%');
thumbContainer.css(
'left',
(percent * 100) + '%'
);
element.toggleClass('md-min', percent === 0);
}
/**
* Slide listeners
*/
var isDragging = false;
var isDiscrete = angular.isDefined(attr.mdDiscrete);
function onPressDown(ev) {
if (isDisabledGetter()) return;
element.addClass('active');
element[0].focus();
refreshSliderDimensions();
var exactVal = percentToValue( positionToPercent( ev.pointer.x ));
var closestVal = minMaxValidator( stepValidator(exactVal) );
scope.$apply(function() {
setModelValue( closestVal );
setSliderPercent( valueToPercent(closestVal));
});
}
function onPressUp(ev) {
if (isDisabledGetter()) return;
element.removeClass('dragging active');
var exactVal = percentToValue( positionToPercent( ev.pointer.x ));
var closestVal = minMaxValidator( stepValidator(exactVal) );
scope.$apply(function() {
setModelValue(closestVal);
ngModelRender();
});
}
function onDragStart(ev) {
if (isDisabledGetter()) return;
isDragging = true;
ev.stopPropagation();
element.addClass('dragging');
setSliderFromEvent(ev);
}
function onDrag(ev) {
if (!isDragging) return;
ev.stopPropagation();
setSliderFromEvent(ev);
}
function onDragEnd(ev) {
if (!isDragging) return;
ev.stopPropagation();
isDragging = false;
}
function setSliderFromEvent(ev) {
// While panning discrete, update only the
// visual positioning but not the model value.
if ( isDiscrete ) adjustThumbPosition( ev.pointer.x );
else doSlide( ev.pointer.x );
}
/**
* Slide the UI by changing the model value
* @param x
*/
function doSlide( x ) {
scope.$evalAsync( function() {
setModelValue( percentToValue( positionToPercent(x) ));
});
}
/**
* Slide the UI without changing the model (while dragging/panning)
* @param x
*/
function adjustThumbPosition( x ) {
var exactVal = percentToValue( positionToPercent( x ));
var closestVal = minMaxValidator( stepValidator(exactVal) );
setSliderPercent( positionToPercent(x) );
thumbText.text( closestVal );
}
/**
* Convert horizontal position on slider to percentage value of offset from beginning...
* @param x
* @returns {number}
*/
function positionToPercent( x ) {
return Math.max(0, Math.min(1, (x - sliderDimensions.left) / (sliderDimensions.width)));
}
/**
* Convert percentage offset on slide to equivalent model value
* @param percent
* @returns {*}
*/
function percentToValue( percent ) {
return (min + percent * (max - min));
}
function valueToPercent( val ) {
return (val - min)/(max - min);
}
}
}
SliderDirective.$inject = ["$$rAF", "$window", "$mdAria", "$mdUtil", "$mdConstant", "$mdTheming", "$mdGesture", "$parse", "$log"];
ng.material.components.slider = angular.module("material.components.slider"); | krossoverintelligence/bower-material | modules/closure/slider/slider.js | JavaScript | mit | 12,825 |
'use strict';
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
var gridElt = document.getElementById('grid');
var grid = function (width, height) {
function createGridArray() {
return new Array(height).fill(new Array(width).fill(false));
}
var _grid = createGridArray();
var frag = document.createDocumentFragment();
_grid.forEach(function (row, i) {
var rowElt = document.createElement('div');
row.forEach(function (cell, j) {
var cellElt = document.createElement('input');
cellElt.type = 'checkbox';
cellElt.className = 'row' + i + ' col' + j;
rowElt.appendChild(cellElt);
});
frag.appendChild(rowElt);
});
gridElt.appendChild(frag);
function _neighbours(rowIndex, colIndex) {
var result = 0;
var row = void 0;
for (var i = rowIndex - 1; i <= rowIndex + 1; i++) {
for (var j = colIndex - 1; j <= colIndex + 1; j++) {
row = _grid[i];
if (row && !(i === rowIndex && j === colIndex)) {
result += !!row[j];
}
}
}
return result;
}
return {
updateCell: function updateCell(i, j, value) {
_grid[i][j] = value;
},
reset: function reset(proportion) {
_grid = _grid.map(function (row) {
return row.map(function () {
return Math.random() > proportion;
});
});
_grid.forEach(function (row, i) {
row.forEach(function (cell, j) {
gridElt.querySelector('.row' + i + '.col' + j).checked = cell;
});
});
},
next: function next() {
var newGrid = [];
_grid.forEach(function (row, i) {
newGrid[i] = [];
row.forEach(function (cell, j) {
var liveNeighbours = _neighbours(i, j);
var newValue = cell && liveNeighbours > 1 && liveNeighbours < 4 || !cell && liveNeighbours === 3;
newGrid[i][j] = newValue;
gridElt.querySelector('.row' + i + '.col' + j).checked = newValue;
});
});
_grid = newGrid;
}
};
}(20, 10);
grid.reset(1);
document.getElementById('next').addEventListener('click', grid.next);
gridElt.addEventListener('click', function (event) {
var cellElt = event.target;
if (cellElt.tagName === 'INPUT') {
grid.updateCell.apply(grid, _toConsumableArray(cellElt.className.split(' ').map(function (s) {
return parseInt(s.slice(3));
})).concat([cellElt.checked]));
}
});
| benjaminchad/benjaminchad.github.io | src/es5/conway.js | JavaScript | mit | 2,551 |
Array.implement({
shuffle:function() {
this.sort(function (x,y) { return Math.random()*3-1; });
return this;
}
});
| 131/yks | rsrcs/js/3rd/Walsh/Native/Array.js | JavaScript | mit | 128 |
/// <autosync enabled="true" />
/// <reference path="../bower_components/angular/angular.js" />
/// <reference path="../bower_components/angular-route/angular-route.js" />
/// <reference path="../bower_components/bootstrap/Gruntfile.js" />
/// <reference path="../bower_components/bootstrap/dist/js/bootstrap.js" />
/// <reference path="../bower_components/bootstrap/dist/js/npm.js" />
/// <reference path="../bower_components/bootstrap/grunt/bs-commonjs-generator.js" />
/// <reference path="../bower_components/bootstrap/grunt/bs-glyphicons-data-generator.js" />
/// <reference path="../bower_components/bootstrap/grunt/bs-lessdoc-parser.js" />
/// <reference path="../bower_components/bootstrap/grunt/bs-raw-files-generator.js" />
/// <reference path="../bower_components/bootstrap/js/affix.js" />
/// <reference path="../bower_components/bootstrap/js/alert.js" />
/// <reference path="../bower_components/bootstrap/js/button.js" />
/// <reference path="../bower_components/bootstrap/js/carousel.js" />
/// <reference path="../bower_components/bootstrap/js/collapse.js" />
/// <reference path="../bower_components/bootstrap/js/dropdown.js" />
/// <reference path="../bower_components/bootstrap/js/modal.js" />
/// <reference path="../bower_components/bootstrap/js/popover.js" />
/// <reference path="../bower_components/bootstrap/js/scrollspy.js" />
/// <reference path="../bower_components/bootstrap/js/tab.js" />
/// <reference path="../bower_components/bootstrap/js/tooltip.js" />
/// <reference path="../bower_components/bootstrap/js/transition.js" />
/// <reference path="../bower_components/jquery/dist/jquery.js" />
/// <reference path="../bower_components/jquery/src/ajax.js" />
/// <reference path="../bower_components/jquery/src/attributes.js" />
/// <reference path="../bower_components/jquery/src/callbacks.js" />
/// <reference path="../bower_components/jquery/src/core.js" />
/// <reference path="../bower_components/jquery/src/css.js" />
/// <reference path="../bower_components/jquery/src/data.js" />
/// <reference path="../bower_components/jquery/src/deferred.js" />
/// <reference path="../bower_components/jquery/src/deprecated.js" />
/// <reference path="../bower_components/jquery/src/dimensions.js" />
/// <reference path="../bower_components/jquery/src/effects.js" />
/// <reference path="../bower_components/jquery/src/event.js" />
/// <reference path="../bower_components/jquery/src/intro.js" />
/// <reference path="../bower_components/jquery/src/jquery.js" />
/// <reference path="../bower_components/jquery/src/manipulation.js" />
/// <reference path="../bower_components/jquery/src/offset.js" />
/// <reference path="../bower_components/jquery/src/outro.js" />
/// <reference path="../bower_components/jquery/src/queue.js" />
/// <reference path="../bower_components/jquery/src/selector-native.js" />
/// <reference path="../bower_components/jquery/src/selector-sizzle.js" />
/// <reference path="../bower_components/jquery/src/selector.js" />
/// <reference path="../bower_components/jquery/src/serialize.js" />
/// <reference path="../bower_components/jquery/src/traversing.js" />
/// <reference path="../bower_components/jquery/src/wrap.js" />
/// <reference path="../bower_components/jquery/src/ajax/jsonp.js" />
/// <reference path="../bower_components/jquery/src/ajax/load.js" />
/// <reference path="../bower_components/jquery/src/ajax/parseJSON.js" />
/// <reference path="../bower_components/jquery/src/ajax/parseXML.js" />
/// <reference path="../bower_components/jquery/src/ajax/script.js" />
/// <reference path="../bower_components/jquery/src/ajax/xhr.js" />
/// <reference path="../bower_components/jquery/src/ajax/var/nonce.js" />
/// <reference path="../bower_components/jquery/src/ajax/var/rquery.js" />
/// <reference path="../bower_components/jquery/src/attributes/attr.js" />
/// <reference path="../bower_components/jquery/src/attributes/classes.js" />
/// <reference path="../bower_components/jquery/src/attributes/prop.js" />
/// <reference path="../bower_components/jquery/src/attributes/support.js" />
/// <reference path="../bower_components/jquery/src/attributes/val.js" />
/// <reference path="../bower_components/jquery/src/core/access.js" />
/// <reference path="../bower_components/jquery/src/core/init.js" />
/// <reference path="../bower_components/jquery/src/core/parseHTML.js" />
/// <reference path="../bower_components/jquery/src/core/ready.js" />
/// <reference path="../bower_components/jquery/src/core/var/rsingleTag.js" />
/// <reference path="../bower_components/jquery/src/css/addGetHookIf.js" />
/// <reference path="../bower_components/jquery/src/css/curCSS.js" />
/// <reference path="../bower_components/jquery/src/css/defaultDisplay.js" />
/// <reference path="../bower_components/jquery/src/css/hiddenVisibleSelectors.js" />
/// <reference path="../bower_components/jquery/src/css/support.js" />
/// <reference path="../bower_components/jquery/src/css/swap.js" />
/// <reference path="../bower_components/jquery/src/css/var/cssExpand.js" />
/// <reference path="../bower_components/jquery/src/css/var/getStyles.js" />
/// <reference path="../bower_components/jquery/src/css/var/isHidden.js" />
/// <reference path="../bower_components/jquery/src/css/var/rmargin.js" />
/// <reference path="../bower_components/jquery/src/css/var/rnumnonpx.js" />
/// <reference path="../bower_components/jquery/src/data/accepts.js" />
/// <reference path="../bower_components/jquery/src/data/Data.js" />
/// <reference path="../bower_components/jquery/src/data/var/data_priv.js" />
/// <reference path="../bower_components/jquery/src/data/var/data_user.js" />
/// <reference path="../bower_components/jquery/src/effects/animatedSelector.js" />
/// <reference path="../bower_components/jquery/src/effects/Tween.js" />
/// <reference path="../bower_components/jquery/src/event/ajax.js" />
/// <reference path="../bower_components/jquery/src/event/alias.js" />
/// <reference path="../bower_components/jquery/src/event/support.js" />
/// <reference path="../bower_components/jquery/src/exports/amd.js" />
/// <reference path="../bower_components/jquery/src/exports/global.js" />
/// <reference path="../bower_components/jquery/src/manipulation/support.js" />
/// <reference path="../bower_components/jquery/src/manipulation/_evalUrl.js" />
/// <reference path="../bower_components/jquery/src/manipulation/var/rcheckableType.js" />
/// <reference path="../bower_components/jquery/src/queue/delay.js" />
/// <reference path="../bower_components/jquery/src/sizzle/dist/sizzle.js" />
/// <reference path="../bower_components/jquery/src/traversing/findFilter.js" />
/// <reference path="../bower_components/jquery/src/traversing/var/rneedsContext.js" />
/// <reference path="../bower_components/jquery/src/var/arr.js" />
/// <reference path="../bower_components/jquery/src/var/class2type.js" />
/// <reference path="../bower_components/jquery/src/var/concat.js" />
/// <reference path="../bower_components/jquery/src/var/hasOwn.js" />
/// <reference path="../bower_components/jquery/src/var/indexOf.js" />
/// <reference path="../bower_components/jquery/src/var/pnum.js" />
/// <reference path="../bower_components/jquery/src/var/push.js" />
/// <reference path="../bower_components/jquery/src/var/rnotwhite.js" />
/// <reference path="../bower_components/jquery/src/var/slice.js" />
/// <reference path="../bower_components/jquery/src/var/strundefined.js" />
/// <reference path="../bower_components/jquery/src/var/support.js" />
/// <reference path="../bower_components/jquery/src/var/toString.js" />
/// <reference path="../app.js" />
/// <reference path="../services/requester.js" />
/// <reference path="../services/baseUrl.js" />
/// <reference path="../services/userSession.js" />
/// <reference path="../controllers/public/LoginController.js" />
/// <reference path="../services/userRequests.js" />
/// <reference path="../services/adminRequests.js" />
/// <reference path="../controllers/admin/AdminHomeController.js" />
/// <reference path="../controllers/admin/order/AdminGiveOrderController.js" />
/// <reference path="../controllers/admin/order/AdminTakeOrderController.js" />
/// <reference path="../controllers/admin/order/AdminOrdersController.js" />
/// <reference path="../services/transplateNamesToEng.js" />
/// <reference path="../bower_components/StickyTableHeaders/js/jquery.stickytableheaders.js" />
/// <reference path="../bower_components/noty/Gruntfile.js" />
/// <reference path="../bower_components/noty/demo/jquery-1.7.2.min.js" />
/// <reference path="../bower_components/noty/demo/jquery-1.8.0.js" />
/// <reference path="../bower_components/noty/demo/notification_html.js" />
/// <reference path="../bower_components/noty/js/noty/jquery.noty.js" />
/// <reference path="../bower_components/noty/js/noty/promise.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/bottom.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/bottomCenter.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/bottomLeft.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/bottomRight.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/center.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/centerLeft.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/centerRight.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/inline.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/top.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/topCenter.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/topLeft.js" />
/// <reference path="../bower_components/noty/js/noty/layouts/topRight.js" />
/// <reference path="../bower_components/noty/js/noty/packaged/jquery.noty.packaged.js" />
/// <reference path="../bower_components/noty/js/noty/themes/bootstrap.js" />
/// <reference path="../bower_components/noty/js/noty/themes/default.js" />
/// <reference path="../bower_components/noty/js/noty/themes/relax.js" />
/// <reference path="../services/notyService.js" />
/// <reference path="../bower_components/angular-ui-bootstrap-bower/ui-bootstrap-tpls.min.js" />
/// <reference path="../bower_components/angular-ui-bootstrap-bower/ui-bootstrap.min.js" />
/// <reference path="../bower_components/angular/index.js" />
/// <reference path="../bower_components/angular-animate/angular-animate.min.js" />
/// <reference path="../bower_components/angular-animate/index.js" />
/// <reference path="../services/helper.js" />
/// <reference path="../services/components/pagination.js" />
/// <reference path="../services/components/datepicker.js" />
/// <reference path="../directives/tableGrid.js" />
/// <reference path="../controllers/admin/table-manage/AdminTableManageController.js" />
/// <reference path="../filters/yesNoFilter.js" />
/// <reference path="../controllers/admin/table-manage/AdminTableItemManageController.js" />
| andrei-bozhilov/Phone-Management-System | PhoneManagementSystem.WebApiClient/Scripts/_references.js | JavaScript | mit | 10,982 |
import Route from '@ember/routing/route';
export default class About extends Route { }
| Nippius/digitalillusion-frontend | app/routes/about.js | JavaScript | mit | 88 |
var webpack = require('webpack');
module.exports = {
entry: {
main : [
'./src/main.js'
],
vendor : ["react","react-redux", "react-dom",
"core-js"]
},
node: {
fs: 'empty',
net: 'empty',
tls: 'empty',
child_process: 'empty'
},
output: {
path: __dirname,
filename: "./dist/bundle.js"
},
devtool : 'source-map',
plugins : [
new webpack.optimize.CommonsChunkPlugin("vendor", "dist/vendor.bundle.js"),
],
module:{
loaders: [{
test: /\.js?$/,
exclude: /node_modules/,
loaders: [
'babel?presets[]=react,presets[]=es2015,presets[]=stage-1'
]
}]
}
}
| userspace/spent | webpack.config.js | JavaScript | mit | 693 |
angular.module('umbraco').directive('circle', function () {
return {
restrict: 'E',
replace: true,
templateUrl: '/App_Plugins/RankOne/directives/circle/circle.directive.html',
scope: {
progress: '=',
mode: '@mode'
}
}
}); | GitCorne/RankOne-Umbraco-SEO-Tool | src/RankOne.SEO.Tool/Web/UI/App_Plugins/RankOne/directives/circle/circle.directive.js | JavaScript | mit | 296 |
// Design Basic Game Solo Challenge
// This is a solo challenge
// Your mission description: Slay the dragon!
// Overall mission: Choose your weapon and attempt to slay the dragon!
// Goals:
// Characters: Knight, Dragon
// Objects: Knight, Dragon, Sword, Axe, Bow and Arrow
// Functions: Attack, Choose Weapon
/* Pseudocode for MVP
Create dragon with 10 health
Create knight with health and open weapon property
Prompt user for type of weapon they want to use and add it to knight
Create attack function which does variable damage to dragon, lowering health by an amount within a range
Also have knight take range of damage after attacking
Create loop where knight attacks until either knight or dragon health reach 0
*/
// Initial Code
var dragon = {
name:"Dragon",
health:10
}
var knight = {
name:"Knight",
health:10,
weapon:"fists"
}
// var axe = {
// name:"Battle Axe",
// damage:Math.floor(Math.random() * 3) + 2,
// returnDamage:Math.floor(Math.random() * 3) + 2
// }
// var sword = {
// name:"Sword and Shield",
// damage:Math.floor(Math.random() * 3) + 1,
// returnDamage:Math.floor(Math.random() * 3) + 1
// }
// var bow = {
// name:"Bow and Arrow",
// damage:Math.floor(Math.random() * 2) + 1,
// returnDamage:Math.floor(Math.random() * 2) + 1
// }
chooseWeapon = function(choice) {
knight.weapon = choice
console.log("Equipped the " + choice.name + "!")
}
attack = function() {
console.log("Attacked the dragon with the " + knight.weapon.name)
var hit = knight.weapon.damage
console.log("Hit for " + hit + " damage")
dragon.health -= hit
var hurt = knight.weapon.returnDamage
console.log("Took " + hurt + " damage from the dragon!")
knight.health -= hurt
}
checkHealth = function() {
console.log('Dragon down to: ' + dragon.health + 'hp')
console.log('You are down to: ' + knight.health + 'hp')
}
battle = function() {
while (dragon.health >0 && knight.health > 0) {
attack()
}
checkHealth()
if (knight.health <= 0) {
console.log("Oh no! You were defeated by the dragon.")
}
else {
console.log("You defeated the dragon!")
}
}
// Refactored Code
function weapon(name,damage,counter) {
this.name = name;
this.damage = Math.floor(Math.random() * damage) + 1;
this.returnDamage = Math.floor(Math.random() * counter) + 1;
}
var axe = new weapon("axe",4,4)
var sword = new weapon("Sword and Shield",3,3)
var bow = new weapon("Bow and Arrow",2,2)
chooseWeapon(axe)
battle()
// // Reflection
// What was the most difficult part of this challenge?
// The most difficult part for me was figuring out what I wanted to do! Once I had an idea of a simple game
// I then spent a good deal of time planning how I would go through it, and I strayed from my Pseudocode because I didn't anticipate how far I wanted to take it.
// What did you learn about creating objects and functions that interact with one another?
// It's important to have good variable names that are descriptive but not confusing so you can reference them easily.
// It also seems easier to make objects that can manipulate other objects in Ruby.
// Did you learn about any new built-in methods you could use in your refactored solution? If so, what were they and how do they work?
// I learned about some different math methods, which I used in my initial solution, and I realized I could use a constructor to make my code cleaner.
// How can you access and manipulate properties of objects?
// object.property
| BenSanex/phase-0 | week-7/game.js | JavaScript | mit | 3,437 |
(function() {
const a= document.querySelector("#demo");
const b= document.querySelector("#n");
const c= document.querySelector("#u");
let stooge = {name: 'moe'};
a.innerText = JSON.stringify(stooge);
//underscore js
const no = ('moe'=== _.property('name')(stooge));
c.innerText = JSON.stringify(no);
//normal js
const n = (Object.values(stooge).indexOf('moe') != -1);
b.innerText = JSON.stringify(n);
}()) | prathap1041220272/underscor-js-to-nromal-js | Objects/property/index.js | JavaScript | mit | 414 |
export default {
name: 'i5xwxdoctor-web',
prefix: '',
footerText: '天津市神州商龙科技有限公司 版权所有',
logoSrc: 'http://wx.qlogo.cn/mmopen/ajNVdqHZLLB1soficE1pC2uTql1MDqCqVqX0jo6pewchVJicXjQzj3V024hfia41tHRCfJJGoY9Pnu6DN1CJxehSg/0',
logoText: 'WEATIT基盘',
needLogin: false
}
| daizhen256/i5xwxdoctor-web | src/utils/config.js | JavaScript | mit | 311 |
'use strict';
/* Services */
angular.module('spBlogger.services',[]); | AppForMine/Angular | app/js/services.js | JavaScript | mit | 71 |
import uniq from 'lodash/uniq';
import { makeCookieArchiver } from '@r/redux-state-archiver';
import { RECENT_CLICKS_LENGTH } from 'app/constants';
const recentClicksSelector = state => {
const recentClicks = state.visitedPosts.concat(Object.keys(state.expandedPosts));
return uniq(recentClicks).slice(0, RECENT_CLICKS_LENGTH);
};
const recentSubredditsSelector = state => {
return state.recentSubreddits
.filter(sub => state.subreddits[sub.toLowerCase()])
.map(sub => state.subreddits[sub.toLowerCase()].name);
};
const combiner = (theme, compact, over18, recentSubreddits, recentClicks, username, euCookieNotice) => {
const res = {
theme,
compact,
over18,
EUCookieNotice: euCookieNotice,
};
res[`${username}_recent_srs`] = recentSubreddits.join(',');
res[`${username}_recentclicks2`] = recentClicks.map(post => `t3_${post}`).join(',');
return res;
};
export default makeCookieArchiver(
state => state.theme,
state => state.compact,
state => state.preferences.over18,
recentSubredditsSelector,
recentClicksSelector,
state => !state.user.loggedOut && state.user.name ? state.user.name : '',
state => state.euCookieNotice.numberOfTimesShown,
combiner,
);
| ajacksified/reddit-mobile | src/app/side-effect-components/CookieSync.js | JavaScript | mit | 1,216 |
define(['angular',
'../namespace',
'angular-elastic'
], function(ng, namespace) {
'use strict';
return ng.module(namespace + '.directives', [
'monospaced.elastic'
]);
});
| nokia-wroclaw/hackathon-goidea | static/js/goidea/directives/module.js | JavaScript | mit | 186 |
'use strict';
import React from 'react';
import ReactDOM from 'react-dom';
import AppContainer from './components/app-container';
import { getEnumList, getList } from './graphql';
Promise.all([
getEnumList('Color', 'widgets'),
getEnumList('Size', 'widgets'),
getList('widgets', 'widgets', ['id', 'name', 'color', 'size', 'quantity', { owner: ['id', 'name'] } ])
.then(results => results.widgets),
getList('users', 'users', ['id', 'name']).then(results =>
results.users.map(user => ({ value: user.id, label: user.name })))
]).then(results => {
return ReactDOM.render(
<AppContainer widgets={results[2]} colorList={results[0]}
sizeList={results[1]} userList={results[3]} />,
document.querySelector('main'));
});
| training4developers/bootcamp_04112016 | src/www/js/demos/index_original.js | JavaScript | mit | 728 |
'use strict';
// This module will increment alphanumeric counters using 0-9 and a-Z
// For example next('a9') => 'aa'
// return null for invalid input
// blacklist is an array of strings you want to skip
exports.next = function next(input, blacklist) {
// lookup for borders of charcode increments
const borders = {
57: 97,
122: 65,
90: 48
};
// return a starting counter if input is falsey
if (!input) {
return '0';
}
// return null if input is otherwise invalid
if (typeof input !== 'string' || input.match(/[^a-zA-Z0-9]/)) {
return null;
}
// incriment and return
let nextStringArr = input.split('');
for (let i = input.length - 1; i >= 0; i--) {
let charCode = nextStringArr[i].charCodeAt(0);
let nextChar;
// is char on a border or not?
if (borders.hasOwnProperty(charCode)) {
nextChar = borders[charCode];
} else {
nextChar = charCode + 1;
}
nextStringArr[i] = String.fromCharCode(nextChar);
// do we need to increment the next character?
if (charCode === 90) {
// do we need to add a new character?
if (i === 0) {
nextStringArr.unshift('0');
i++;
} else {
continue;
}
}
let nextString = nextStringArr.join('');
// is this string blacklisted?
if (blacklist && blacklist.indexOf(nextString) > -1) {
return this.next(nextString, blacklist);
}
return nextString;
}
};
| ltegman/alpha-inc | index.js | JavaScript | mit | 1,449 |
var hbs = require('express-hbs'),
Promise = require('bluebird'),
errors = require('../errors'),
utils = require('./utils'),
coreHelpers = {},
registerHelpers;
// Pre-load settings data:
// - activeTheme
// - permalinks
if (!utils.isProduction) {
hbs.handlebars.logger.level = 0;
}
coreHelpers.asset = require('./asset');
coreHelpers.author = require('./author');
coreHelpers.body_class = require('./body_class');
coreHelpers.content = require('./content');
coreHelpers.date = require('./date');
coreHelpers.encode = require('./encode');
coreHelpers.excerpt = require('./excerpt');
coreHelpers.foreach = require('./foreach');
coreHelpers.ghost_foot = require('./ghost_foot');
coreHelpers.ghost_head = require('./ghost_head');
coreHelpers.is = require('./is');
coreHelpers.has = require('./has');
coreHelpers.meta_description = require('./meta_description');
coreHelpers.meta_title = require('./meta_title');
coreHelpers.navigation = require('./navigation');
coreHelpers.page_url = require('./page_url');
coreHelpers.pageUrl = require('./page_url').deprecated;
coreHelpers.pagination = require('./pagination');
coreHelpers.plural = require('./plural');
coreHelpers.post_class = require('./post_class');
coreHelpers.tags = require('./tags');
coreHelpers.title = require('./title');
coreHelpers.url = require('./url');
coreHelpers.image = require('./image');
coreHelpers.tag_cloud = require('./tag_cloud');
coreHelpers.ghost_script_tags = require('./ghost_script_tags');
coreHelpers.helperMissing = function (arg) {
if (arguments.length === 2) {
return undefined;
}
errors.logError('Missing helper: "' + arg + '"');
};
// Register an async handlebars helper for a given handlebars instance
function registerAsyncHelper(hbs, name, fn) {
hbs.registerAsyncHelper(name, function (options, cb) {
// Wrap the function passed in with a when.resolve so it can
// return either a promise or a value
Promise.resolve(fn.call(this, options)).then(function (result) {
cb(result);
}).catch(function (err) {
errors.logAndThrowError(err, 'registerAsyncThemeHelper: ' + name);
});
});
}
// Register a handlebars helper for themes
function registerThemeHelper(name, fn) {
hbs.registerHelper(name, fn);
}
// Register an async handlebars helper for themes
function registerAsyncThemeHelper(name, fn) {
registerAsyncHelper(hbs, name, fn);
}
// Register a handlebars helper for admin
function registerAdminHelper(name, fn) {
coreHelpers.adminHbs.registerHelper(name, fn);
}
registerHelpers = function (adminHbs) {
// Expose hbs instance for admin
coreHelpers.adminHbs = adminHbs;
// Register theme helpers
registerThemeHelper('asset', coreHelpers.asset);
registerThemeHelper('author', coreHelpers.author);
registerThemeHelper('content', coreHelpers.content);
registerThemeHelper('title', coreHelpers.title);
registerThemeHelper('date', coreHelpers.date);
registerThemeHelper('encode', coreHelpers.encode);
registerThemeHelper('excerpt', coreHelpers.excerpt);
registerThemeHelper('foreach', coreHelpers.foreach);
registerThemeHelper('is', coreHelpers.is);
registerThemeHelper('has', coreHelpers.has);
registerThemeHelper('navigation', coreHelpers.navigation);
registerThemeHelper('page_url', coreHelpers.page_url);
registerThemeHelper('pageUrl', coreHelpers.pageUrl);
registerThemeHelper('pagination', coreHelpers.pagination);
registerThemeHelper('tags', coreHelpers.tags);
registerThemeHelper('plural', coreHelpers.plural);
registerThemeHelper('url', coreHelpers.url);
registerThemeHelper('image', coreHelpers.image);
// Async theme helpers
registerAsyncThemeHelper('body_class', coreHelpers.body_class);
registerAsyncThemeHelper('ghost_foot', coreHelpers.ghost_foot);
registerAsyncThemeHelper('ghost_head', coreHelpers.ghost_head);
registerAsyncThemeHelper('meta_description', coreHelpers.meta_description);
registerAsyncThemeHelper('meta_title', coreHelpers.meta_title);
registerAsyncThemeHelper('post_class', coreHelpers.post_class);
registerAsyncThemeHelper('tag_cloud', coreHelpers.tag_cloud);
// Register admin helpers
registerAdminHelper('ghost_script_tags', coreHelpers.ghost_script_tags);
registerAdminHelper('asset', coreHelpers.asset);
};
module.exports = coreHelpers;
module.exports.loadCoreHelpers = registerHelpers;
module.exports.registerThemeHelper = registerThemeHelper;
module.exports.registerAsyncThemeHelper = registerAsyncThemeHelper;
module.exports.scriptFiles = utils.scriptFiles;
| salcabar/ued_ghost_project | core/server/helpers/index.js | JavaScript | mit | 4,698 |
// Karma configuration file
//
// For all available config options and default values, see:
// https://github.com/karma-runner/karma/blob/stable/lib/config.js#L54
module.exports = function (config) {
'use strict';
config.set({
// base path, that will be used to resolve files and exclude
basePath: '',
frameworks: [
'mocha'
],
// list of files / patterns to load in the browser
files: [
'bower_components/chai/chai.js',
'test/mock/result.js',
'palindromes.js',
'test/**/*.js'
],
// use dots reporter, as travis terminal does not support escaping sequences
// possible values: 'dots', 'progress', 'junit', 'teamcity'
// CLI --reporters progress
//reporters: ['dots'],
reporters: ['progress', 'coverage'],
preprocessors: {
'palindromes.js': 'coverage'
},
coverageReporter: {
type: 'lcov',
dir: 'coverage/'
},
// enable / disable watching file and executing tests whenever any file changes
// CLI --auto-watch --no-auto-watch
autoWatch: true,
// start these browsers
// CLI --browsers Chrome,Firefox,Safari
browsers: [
'IE',
'Firefox',
'Opera',
'Chrome'
],
// if browser does not capture in given timeout [ms], kill it
// CLI --capture-timeout 5000
captureTimeout: 20000,
// auto run tests on start (when browsers are captured) and exit
// CLI --single-run --no-single-run
singleRun: false,
plugins: [
'karma-mocha',
'karma-requirejs',
'karma-phantomjs-launcher',
'karma-chrome-launcher',
'karma-firefox-launcher',
'karma-ie-launcher',
'karma-safari-launcher',
'karma-opera-launcher',
'karma-coverage'
]
});
}; | mehranhatami/palindromes | karma.conf.js | JavaScript | mit | 1,774 |
// Copyright (c) 2012 Ecma International. All rights reserved.
// Ecma International makes this code available under the terms and conditions set
// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the
// "Use Terms"). Any redistribution of this code must retain the above
// copyright and this notice and otherwise comply with the Use Terms.
/*---
es5id: 15.4.4.21-3-11
description: >
Array.prototype.reduce - 'length' is a string containing a
positive number
includes: [runTestCase.js]
---*/
function testcase() {
function callbackfn(prevVal, curVal, idx, obj) {
return (curVal === 11 && idx === 1);
}
var obj = { 1: 11, 2: 9, length: "2" };
return Array.prototype.reduce.call(obj, callbackfn, 1) === true;
}
runTestCase(testcase);
| PiotrDabkowski/Js2Py | tests/test_cases/built-ins/Array/prototype/reduce/15.4.4.21-3-11.js | JavaScript | mit | 819 |
import test from 'ava';
import snapshot from '../../helpers/snapshot';
import Vue from 'vue/dist/vue.common.js';
import del from '../../../src/lib/components/del/index.vue';
import commonTest from '../../common/unit';
const testOptions = {
test,
Vue,
snapshot,
component : window.morning._origin.Form.extend(del),
name : 'del',
attrs : ``,
uiid : 2,
delVmEl : false,
_baseTestHookCustomMount : false
};
commonTest.componentBase(testOptions);
| Morning-UI/morning-ui | test/unit/components/del.js | JavaScript | mit | 592 |
'use strict';
var through = require('through2');
var gutil = require('gulp-util');
var PluginError = gutil.PluginError;
var gss_compiler = require('gss-compiler');
var PLUGIN_NAME = 'gulp-gss';
function gulpGss() {
var stream = through.obj(function(file, enc, cb){
if (file.isStream()) {
this.emit('error', new PluginError(PLUGIN_NAME, 'Streams are not supported!'));
}
if (file.isBuffer()){
try {
file.contents = new Buffer( JSON.stringify( gss_compiler.compile(file.contents.toString()) ) );
} catch (e) {
console.log('It has been an error.');
console.trace();
this.emit('error', new PluginError(PLUGIN_NAME, 'Compiling error. ' + e, {
fileName: file.path,
showStack: true
}));
}
}
// make sure the file goes through the next gulp plugin
this.push( file );
// tell the stream engine that we are done with this file
cb();
});
// return the file stream
return stream;
};
// export the plugin function
module.exports = gulpGss;
| franleplant/gulp-gss | index.js | JavaScript | mit | 1,204 |
import { Component } from 'react'
import T from 'prop-types'
import NProgress from 'nprogress'
export default class Bundle extends Component {
static propTypes = {
load: T.func.isRequired,
children: T.func.isRequired
}
state = {mod: null}
componentWillMount () {
this.load(this.props)
NProgress.start()
}
componentDidMount () {
NProgress.done()
this._isMounted = true
}
componentWillReceiveProps (nextProps) {
if (nextProps.load !== this.props.load) {
this.load(nextProps)
}
}
componentWillUnmount () {
this._isMounted = false
}
async load (props) {
this.setState({mod: null})
const module = await props.load()
if (this._isMounted) {
this.setState({mod: module.default || module})
}
}
render () {
return this.state.mod ? this.props.children(this.state.mod) : null
}
}
| Joe3Ray/blog | app/components/bundle/index.js | JavaScript | mit | 876 |
(function() {var implementors = {};
implementors["spin"] = ["impl<'a, T: ?<a class='trait' href='https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html' title='core::marker::Sized'>Sized</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/ops/trait.DerefMut.html' title='core::ops::DerefMut'>DerefMut</a> for <a class='struct' href='spin/struct.MutexGuard.html' title='spin::MutexGuard'>MutexGuard</a><'a, T>","impl<'rwlock, T: ?<a class='trait' href='https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html' title='core::marker::Sized'>Sized</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/ops/trait.DerefMut.html' title='core::ops::DerefMut'>DerefMut</a> for <a class='struct' href='spin/struct.RwLockWriteGuard.html' title='spin::RwLockWriteGuard'>RwLockWriteGuard</a><'rwlock, T>",];
if (window.register_implementors) {
window.register_implementors(implementors);
} else {
window.pending_implementors = implementors;
}
})()
| alchemy-os/alchemy | docs/implementors/core/ops/trait.DerefMut.js | JavaScript | mit | 1,109 |
// -----------------------
// Test
// --------------------
var Storage = require('node-document-storage');
module.exports = Storage.Spec('Redis', {
module: require('..'),
engine: require('redis'),
id: 'redis',
protocol: 'redis',
db: 'default-test',
default_url: 'redis://localhost:6379/default-test',
authorized_url: 'redis://redistogo:57c5cf5c220a6b376cf3740297e0f69f@slimehead.redistogo.com:9501/test',
unauthorized_url: 'redis://redistogo:123@slimehead.redistogo.com:9501/test',
client: {
get: function(db, type, id, callback) {
var key = [db, type, id].join('/');
var client = require('redis').createClient(6379, 'localhost');
client.get(key, function(err, res) {
callback(err, res);
});
},
set: function(db, type, id, data, callback) {
var key = [db, type, id].join('/');
var client = require('redis').createClient(6379, 'localhost');
client.set(key, data, function(err, res) {
callback(err, res);
});
},
del: function(db, type, id, callback) {
var key = [db, type, id].join('/');
var client = require('redis').createClient(6379, 'localhost');
client.del(key, function(err, res) {
callback(err, res);
});
},
exists: function(db, type, id, callback) {
var key = [db, type, id].join('/');
var client = require('redis').createClient(6379, 'localhost');
client.exists(key, function(err, res) {
callback(err, res);
});
}
}
});
| grimen/node-document-storage-redis | test/index.js | JavaScript | mit | 1,522 |
/**
* Created by Administrator on 2014/07/23.
*/
var os = require('os'),
url = require('url'),
http = require('http'),
cluster = require('cluster'),
path = require('path');
var newLogger = require('./libs/NewLogger'),
server = require("./libs/Server"),
router = require("./libs/Router"),
requestHandlers = require("./libs/RequestHandlers");
var handle = {};
if(cluster.isMaster){
newLogger.configure('master');
var logger = newLogger.logger('main');
os.cpus().forEach(function(){
cluster.fork();
});
logger.info('Master[%d], with pid[%d], has started.', cluster.id, process.pid);
}else{
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;
server.service(router.route, handle, cluster);
} | zhoushineyoung/node_cluster_log4js | main.js | JavaScript | mit | 835 |
import {
BufferAttribute,
BufferGeometry,
Color,
FileLoader,
Group,
LineBasicMaterial,
LineSegments,
Loader,
Matrix4,
Mesh,
MeshStandardMaterial,
ShaderMaterial,
UniformsLib,
UniformsUtils,
Vector3,
Ray
} from '../../../build/three.module.js';
// Special surface finish tag types.
// Note: "MATERIAL" tag (e.g. GLITTER, SPECKLE) is not implemented
const FINISH_TYPE_DEFAULT = 0;
const FINISH_TYPE_CHROME = 1;
const FINISH_TYPE_PEARLESCENT = 2;
const FINISH_TYPE_RUBBER = 3;
const FINISH_TYPE_MATTE_METALLIC = 4;
const FINISH_TYPE_METAL = 5;
// State machine to search a subobject path.
// The LDraw standard establishes these various possible subfolders.
const FILE_LOCATION_AS_IS = 0;
const FILE_LOCATION_TRY_PARTS = 1;
const FILE_LOCATION_TRY_P = 2;
const FILE_LOCATION_TRY_MODELS = 3;
const FILE_LOCATION_TRY_RELATIVE = 4;
const FILE_LOCATION_TRY_ABSOLUTE = 5;
const FILE_LOCATION_NOT_FOUND = 6;
const _tempVec0 = new Vector3();
const _tempVec1 = new Vector3();
class LDrawConditionalLineMaterial extends ShaderMaterial {
constructor( parameters ) {
super( {
uniforms: UniformsUtils.merge( [
UniformsLib.fog,
{
diffuse: {
value: new Color()
},
opacity: {
value: 1.0
}
}
] ),
vertexShader: /* glsl */`
attribute vec3 control0;
attribute vec3 control1;
attribute vec3 direction;
varying float discardFlag;
#include <common>
#include <color_pars_vertex>
#include <fog_pars_vertex>
#include <logdepthbuf_pars_vertex>
#include <clipping_planes_pars_vertex>
void main() {
#include <color_vertex>
vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
gl_Position = projectionMatrix * mvPosition;
// Transform the line segment ends and control points into camera clip space
vec4 c0 = projectionMatrix * modelViewMatrix * vec4( control0, 1.0 );
vec4 c1 = projectionMatrix * modelViewMatrix * vec4( control1, 1.0 );
vec4 p0 = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
vec4 p1 = projectionMatrix * modelViewMatrix * vec4( position + direction, 1.0 );
c0.xy /= c0.w;
c1.xy /= c1.w;
p0.xy /= p0.w;
p1.xy /= p1.w;
// Get the direction of the segment and an orthogonal vector
vec2 dir = p1.xy - p0.xy;
vec2 norm = vec2( -dir.y, dir.x );
// Get control point directions from the line
vec2 c0dir = c0.xy - p1.xy;
vec2 c1dir = c1.xy - p1.xy;
// If the vectors to the controls points are pointed in different directions away
// from the line segment then the line should not be drawn.
float d0 = dot( normalize( norm ), normalize( c0dir ) );
float d1 = dot( normalize( norm ), normalize( c1dir ) );
discardFlag = float( sign( d0 ) != sign( d1 ) );
#include <logdepthbuf_vertex>
#include <clipping_planes_vertex>
#include <fog_vertex>
}
`,
fragmentShader: /* glsl */`
uniform vec3 diffuse;
uniform float opacity;
varying float discardFlag;
#include <common>
#include <color_pars_fragment>
#include <fog_pars_fragment>
#include <logdepthbuf_pars_fragment>
#include <clipping_planes_pars_fragment>
void main() {
if ( discardFlag > 0.5 ) discard;
#include <clipping_planes_fragment>
vec3 outgoingLight = vec3( 0.0 );
vec4 diffuseColor = vec4( diffuse, opacity );
#include <logdepthbuf_fragment>
#include <color_fragment>
outgoingLight = diffuseColor.rgb; // simple shader
gl_FragColor = vec4( outgoingLight, diffuseColor.a );
#include <tonemapping_fragment>
#include <encodings_fragment>
#include <fog_fragment>
#include <premultiplied_alpha_fragment>
}
`,
} );
Object.defineProperties( this, {
opacity: {
get: function () {
return this.uniforms.opacity.value;
},
set: function ( value ) {
this.uniforms.opacity.value = value;
}
},
color: {
get: function () {
return this.uniforms.diffuse.value;
}
}
} );
this.setValues( parameters );
this.isLDrawConditionalLineMaterial = true;
}
}
function generateFaceNormals( faces ) {
for ( let i = 0, l = faces.length; i < l; i ++ ) {
const face = faces[ i ];
const vertices = face.vertices;
const v0 = vertices[ 0 ];
const v1 = vertices[ 1 ];
const v2 = vertices[ 2 ];
_tempVec0.subVectors( v1, v0 );
_tempVec1.subVectors( v2, v1 );
face.faceNormal = new Vector3()
.crossVectors( _tempVec0, _tempVec1 )
.normalize();
}
}
const _ray = new Ray();
function smoothNormals( faces, lineSegments, checkSubSegments = false ) {
function hashVertex( v ) {
// NOTE: 1e2 is pretty coarse but was chosen because it allows edges
// to be smoothed as expected (see minifig arms). The errors between edges
// could be due to matrix multiplication.
const x = ~ ~ ( v.x * 1e2 );
const y = ~ ~ ( v.y * 1e2 );
const z = ~ ~ ( v.z * 1e2 );
return `${ x },${ y },${ z }`;
}
function hashEdge( v0, v1 ) {
return `${ hashVertex( v0 ) }_${ hashVertex( v1 ) }`;
}
// converts the two vertices to a ray with a normalized direction and origin of 0, 0, 0 projected
// onto the original line.
function toNormalizedRay( v0, v1, targetRay ) {
targetRay.direction.subVectors( v1, v0 ).normalize();
const scalar = v0.dot( targetRay.direction );
targetRay.origin.copy( v0 ).addScaledVector( targetRay.direction, - scalar );
return targetRay;
}
function hashRay( ray ) {
return hashEdge( ray.origin, ray.direction );
}
const hardEdges = new Set();
const hardEdgeRays = new Map();
const halfEdgeList = {};
const normals = [];
// Save the list of hard edges by hash
for ( let i = 0, l = lineSegments.length; i < l; i ++ ) {
const ls = lineSegments[ i ];
const vertices = ls.vertices;
const v0 = vertices[ 0 ];
const v1 = vertices[ 1 ];
hardEdges.add( hashEdge( v0, v1 ) );
hardEdges.add( hashEdge( v1, v0 ) );
// only generate the hard edge ray map if we're checking subsegments because it's more expensive to check
// and requires more memory.
if ( checkSubSegments ) {
// add both ray directions to the map
const ray = toNormalizedRay( v0, v1, new Ray() );
const rh1 = hashRay( ray );
if ( ! hardEdgeRays.has( rh1 ) ) {
toNormalizedRay( v1, v0, ray );
const rh2 = hashRay( ray );
const info = {
ray,
distances: [],
};
hardEdgeRays.set( rh1, info );
hardEdgeRays.set( rh2, info );
}
// store both segments ends in min, max order in the distances array to check if a face edge is a
// subsegment later.
const info = hardEdgeRays.get( rh1 );
let d0 = info.ray.direction.dot( v0 );
let d1 = info.ray.direction.dot( v1 );
if ( d0 > d1 ) {
[ d0, d1 ] = [ d1, d0 ];
}
info.distances.push( d0, d1 );
}
}
// track the half edges associated with each triangle
for ( let i = 0, l = faces.length; i < l; i ++ ) {
const tri = faces[ i ];
const vertices = tri.vertices;
const vertCount = vertices.length;
for ( let i2 = 0; i2 < vertCount; i2 ++ ) {
const index = i2;
const next = ( i2 + 1 ) % vertCount;
const v0 = vertices[ index ];
const v1 = vertices[ next ];
const hash = hashEdge( v0, v1 );
// don't add the triangle if the edge is supposed to be hard
if ( hardEdges.has( hash ) ) {
continue;
}
// if checking subsegments then check to see if this edge lies on a hard edge ray and whether its within any ray bounds
if ( checkSubSegments ) {
toNormalizedRay( v0, v1, _ray );
const rayHash = hashRay( _ray );
if ( hardEdgeRays.has( rayHash ) ) {
const info = hardEdgeRays.get( rayHash );
const { ray, distances } = info;
let d0 = ray.direction.dot( v0 );
let d1 = ray.direction.dot( v1 );
if ( d0 > d1 ) {
[ d0, d1 ] = [ d1, d0 ];
}
// return early if the face edge is found to be a subsegment of a line edge meaning the edge will have "hard" normals
let found = false;
for ( let i = 0, l = distances.length; i < l; i += 2 ) {
if ( d0 >= distances[ i ] && d1 <= distances[ i + 1 ] ) {
found = true;
break;
}
}
if ( found ) {
continue;
}
}
}
const info = {
index: index,
tri: tri
};
halfEdgeList[ hash ] = info;
}
}
// Iterate until we've tried to connect all faces to share normals
while ( true ) {
// Stop if there are no more faces left
let halfEdge = null;
for ( const key in halfEdgeList ) {
halfEdge = halfEdgeList[ key ];
break;
}
if ( halfEdge === null ) {
break;
}
// Exhaustively find all connected faces
const queue = [ halfEdge ];
while ( queue.length > 0 ) {
// initialize all vertex normals in this triangle
const tri = queue.pop().tri;
const vertices = tri.vertices;
const vertNormals = tri.normals;
const faceNormal = tri.faceNormal;
// Check if any edge is connected to another triangle edge
const vertCount = vertices.length;
for ( let i2 = 0; i2 < vertCount; i2 ++ ) {
const index = i2;
const next = ( i2 + 1 ) % vertCount;
const v0 = vertices[ index ];
const v1 = vertices[ next ];
// delete this triangle from the list so it won't be found again
const hash = hashEdge( v0, v1 );
delete halfEdgeList[ hash ];
const reverseHash = hashEdge( v1, v0 );
const otherInfo = halfEdgeList[ reverseHash ];
if ( otherInfo ) {
const otherTri = otherInfo.tri;
const otherIndex = otherInfo.index;
const otherNormals = otherTri.normals;
const otherVertCount = otherNormals.length;
const otherFaceNormal = otherTri.faceNormal;
// NOTE: If the angle between faces is > 67.5 degrees then assume it's
// hard edge. There are some cases where the line segments do not line up exactly
// with or span multiple triangle edges (see Lunar Vehicle wheels).
if ( Math.abs( otherTri.faceNormal.dot( tri.faceNormal ) ) < 0.25 ) {
continue;
}
// if this triangle has already been traversed then it won't be in
// the halfEdgeList. If it has not then add it to the queue and delete
// it so it won't be found again.
if ( reverseHash in halfEdgeList ) {
queue.push( otherInfo );
delete halfEdgeList[ reverseHash ];
}
// share the first normal
const otherNext = ( otherIndex + 1 ) % otherVertCount;
if (
vertNormals[ index ] && otherNormals[ otherNext ] &&
vertNormals[ index ] !== otherNormals[ otherNext ]
) {
otherNormals[ otherNext ].norm.add( vertNormals[ index ].norm );
vertNormals[ index ].norm = otherNormals[ otherNext ].norm;
}
let sharedNormal1 = vertNormals[ index ] || otherNormals[ otherNext ];
if ( sharedNormal1 === null ) {
// it's possible to encounter an edge of a triangle that has already been traversed meaning
// both edges already have different normals defined and shared. To work around this we create
// a wrapper object so when those edges are merged the normals can be updated everywhere.
sharedNormal1 = { norm: new Vector3() };
normals.push( sharedNormal1.norm );
}
if ( vertNormals[ index ] === null ) {
vertNormals[ index ] = sharedNormal1;
sharedNormal1.norm.add( faceNormal );
}
if ( otherNormals[ otherNext ] === null ) {
otherNormals[ otherNext ] = sharedNormal1;
sharedNormal1.norm.add( otherFaceNormal );
}
// share the second normal
if (
vertNormals[ next ] && otherNormals[ otherIndex ] &&
vertNormals[ next ] !== otherNormals[ otherIndex ]
) {
otherNormals[ otherIndex ].norm.add( vertNormals[ next ].norm );
vertNormals[ next ].norm = otherNormals[ otherIndex ].norm;
}
let sharedNormal2 = vertNormals[ next ] || otherNormals[ otherIndex ];
if ( sharedNormal2 === null ) {
sharedNormal2 = { norm: new Vector3() };
normals.push( sharedNormal2.norm );
}
if ( vertNormals[ next ] === null ) {
vertNormals[ next ] = sharedNormal2;
sharedNormal2.norm.add( faceNormal );
}
if ( otherNormals[ otherIndex ] === null ) {
otherNormals[ otherIndex ] = sharedNormal2;
sharedNormal2.norm.add( otherFaceNormal );
}
}
}
}
}
// The normals of each face have been added up so now we average them by normalizing the vector.
for ( let i = 0, l = normals.length; i < l; i ++ ) {
normals[ i ].normalize();
}
}
function isPartType( type ) {
return type === 'Part';
}
function isModelType( type ) {
return type === 'Model' || type === 'Unofficial_Model';
}
function isPrimitiveType( type ) {
return /primitive/i.test( type ) || type === 'Subpart';
}
class LineParser {
constructor( line, lineNumber ) {
this.line = line;
this.lineLength = line.length;
this.currentCharIndex = 0;
this.currentChar = ' ';
this.lineNumber = lineNumber;
}
seekNonSpace() {
while ( this.currentCharIndex < this.lineLength ) {
this.currentChar = this.line.charAt( this.currentCharIndex );
if ( this.currentChar !== ' ' && this.currentChar !== '\t' ) {
return;
}
this.currentCharIndex ++;
}
}
getToken() {
const pos0 = this.currentCharIndex ++;
// Seek space
while ( this.currentCharIndex < this.lineLength ) {
this.currentChar = this.line.charAt( this.currentCharIndex );
if ( this.currentChar === ' ' || this.currentChar === '\t' ) {
break;
}
this.currentCharIndex ++;
}
const pos1 = this.currentCharIndex;
this.seekNonSpace();
return this.line.substring( pos0, pos1 );
}
getVector() {
return new Vector3( parseFloat( this.getToken() ), parseFloat( this.getToken() ), parseFloat( this.getToken() ) );
}
getRemainingString() {
return this.line.substring( this.currentCharIndex, this.lineLength );
}
isAtTheEnd() {
return this.currentCharIndex >= this.lineLength;
}
setToEnd() {
this.currentCharIndex = this.lineLength;
}
getLineNumberString() {
return this.lineNumber >= 0 ? ' at line ' + this.lineNumber : '';
}
}
class LDrawFileCache {
constructor( loader ) {
this.cache = {};
this.loader = loader;
}
setData( key, contents ) {
this.cache[ key.toLowerCase() ] = contents;
}
async loadData( fileName ) {
const key = fileName.toLowerCase();
if ( key in this.cache ) {
return this.cache[ key ];
}
this.cache[ fileName ] = new Promise( async ( resolve, reject ) => {
let triedLowerCase = false;
let locationState = FILE_LOCATION_AS_IS;
while ( locationState !== FILE_LOCATION_NOT_FOUND ) {
let subobjectURL = fileName;
switch ( locationState ) {
case FILE_LOCATION_AS_IS:
locationState = locationState + 1;
break;
case FILE_LOCATION_TRY_PARTS:
subobjectURL = 'parts/' + subobjectURL;
locationState = locationState + 1;
break;
case FILE_LOCATION_TRY_P:
subobjectURL = 'p/' + subobjectURL;
locationState = locationState + 1;
break;
case FILE_LOCATION_TRY_MODELS:
subobjectURL = 'models/' + subobjectURL;
locationState = locationState + 1;
break;
case FILE_LOCATION_TRY_RELATIVE:
subobjectURL = fileName.substring( 0, fileName.lastIndexOf( '/' ) + 1 ) + subobjectURL;
locationState = locationState + 1;
break;
case FILE_LOCATION_TRY_ABSOLUTE:
if ( triedLowerCase ) {
// Try absolute path
locationState = FILE_LOCATION_NOT_FOUND;
} else {
// Next attempt is lower case
fileName = fileName.toLowerCase();
subobjectURL = fileName;
triedLowerCase = true;
locationState = FILE_LOCATION_AS_IS;
}
break;
}
const loader = this.loader;
const fileLoader = new FileLoader( loader.manager );
fileLoader.setPath( loader.partsLibraryPath );
fileLoader.setRequestHeader( loader.requestHeader );
fileLoader.setWithCredentials( loader.withCredentials );
try {
const text = await fileLoader.loadAsync( subobjectURL );
this.setData( fileName, text );
resolve( text );
return;
} catch {
continue;
}
}
reject();
} );
return this.cache[ fileName ];
}
}
function sortByMaterial( a, b ) {
if ( a.colourCode === b.colourCode ) {
return 0;
}
if ( a.colourCode < b.colourCode ) {
return - 1;
}
return 1;
}
function createObject( elements, elementSize, isConditionalSegments = false, totalElements = null ) {
// Creates a LineSegments (elementSize = 2) or a Mesh (elementSize = 3 )
// With per face / segment material, implemented with mesh groups and materials array
// Sort the faces or line segments by colour code to make later the mesh groups
elements.sort( sortByMaterial );
if ( totalElements === null ) {
totalElements = elements.length;
}
const positions = new Float32Array( elementSize * totalElements * 3 );
const normals = elementSize === 3 ? new Float32Array( elementSize * totalElements * 3 ) : null;
const materials = [];
const quadArray = new Array( 6 );
const bufferGeometry = new BufferGeometry();
let prevMaterial = null;
let index0 = 0;
let numGroupVerts = 0;
let offset = 0;
for ( let iElem = 0, nElem = elements.length; iElem < nElem; iElem ++ ) {
const elem = elements[ iElem ];
let vertices = elem.vertices;
if ( vertices.length === 4 ) {
quadArray[ 0 ] = vertices[ 0 ];
quadArray[ 1 ] = vertices[ 1 ];
quadArray[ 2 ] = vertices[ 2 ];
quadArray[ 3 ] = vertices[ 0 ];
quadArray[ 4 ] = vertices[ 2 ];
quadArray[ 5 ] = vertices[ 3 ];
vertices = quadArray;
}
for ( let j = 0, l = vertices.length; j < l; j ++ ) {
const v = vertices[ j ];
const index = offset + j * 3;
positions[ index + 0 ] = v.x;
positions[ index + 1 ] = v.y;
positions[ index + 2 ] = v.z;
}
// create the normals array if this is a set of faces
if ( elementSize === 3 ) {
if ( ! elem.faceNormal ) {
const v0 = vertices[ 0 ];
const v1 = vertices[ 1 ];
const v2 = vertices[ 2 ];
_tempVec0.subVectors( v1, v0 );
_tempVec1.subVectors( v2, v1 );
elem.faceNormal = new Vector3()
.crossVectors( _tempVec0, _tempVec1 )
.normalize();
}
let elemNormals = elem.normals;
if ( elemNormals.length === 4 ) {
quadArray[ 0 ] = elemNormals[ 0 ];
quadArray[ 1 ] = elemNormals[ 1 ];
quadArray[ 2 ] = elemNormals[ 2 ];
quadArray[ 3 ] = elemNormals[ 0 ];
quadArray[ 4 ] = elemNormals[ 2 ];
quadArray[ 5 ] = elemNormals[ 3 ];
elemNormals = quadArray;
}
for ( let j = 0, l = elemNormals.length; j < l; j ++ ) {
// use face normal if a vertex normal is not provided
let n = elem.faceNormal;
if ( elemNormals[ j ] ) {
n = elemNormals[ j ].norm;
}
const index = offset + j * 3;
normals[ index + 0 ] = n.x;
normals[ index + 1 ] = n.y;
normals[ index + 2 ] = n.z;
}
}
if ( prevMaterial !== elem.material ) {
if ( prevMaterial !== null ) {
bufferGeometry.addGroup( index0, numGroupVerts, materials.length - 1 );
}
materials.push( elem.material );
prevMaterial = elem.material;
index0 = offset / 3;
numGroupVerts = vertices.length;
} else {
numGroupVerts += vertices.length;
}
offset += 3 * vertices.length;
}
if ( numGroupVerts > 0 ) {
bufferGeometry.addGroup( index0, Infinity, materials.length - 1 );
}
bufferGeometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
if ( normals !== null ) {
bufferGeometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
}
let object3d = null;
if ( elementSize === 2 ) {
object3d = new LineSegments( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
} else if ( elementSize === 3 ) {
object3d = new Mesh( bufferGeometry, materials.length === 1 ? materials[ 0 ] : materials );
}
if ( isConditionalSegments ) {
object3d.isConditionalLine = true;
const controlArray0 = new Float32Array( elements.length * 3 * 2 );
const controlArray1 = new Float32Array( elements.length * 3 * 2 );
const directionArray = new Float32Array( elements.length * 3 * 2 );
for ( let i = 0, l = elements.length; i < l; i ++ ) {
const os = elements[ i ];
const vertices = os.vertices;
const controlPoints = os.controlPoints;
const c0 = controlPoints[ 0 ];
const c1 = controlPoints[ 1 ];
const v0 = vertices[ 0 ];
const v1 = vertices[ 1 ];
const index = i * 3 * 2;
controlArray0[ index + 0 ] = c0.x;
controlArray0[ index + 1 ] = c0.y;
controlArray0[ index + 2 ] = c0.z;
controlArray0[ index + 3 ] = c0.x;
controlArray0[ index + 4 ] = c0.y;
controlArray0[ index + 5 ] = c0.z;
controlArray1[ index + 0 ] = c1.x;
controlArray1[ index + 1 ] = c1.y;
controlArray1[ index + 2 ] = c1.z;
controlArray1[ index + 3 ] = c1.x;
controlArray1[ index + 4 ] = c1.y;
controlArray1[ index + 5 ] = c1.z;
directionArray[ index + 0 ] = v1.x - v0.x;
directionArray[ index + 1 ] = v1.y - v0.y;
directionArray[ index + 2 ] = v1.z - v0.z;
directionArray[ index + 3 ] = v1.x - v0.x;
directionArray[ index + 4 ] = v1.y - v0.y;
directionArray[ index + 5 ] = v1.z - v0.z;
}
bufferGeometry.setAttribute( 'control0', new BufferAttribute( controlArray0, 3, false ) );
bufferGeometry.setAttribute( 'control1', new BufferAttribute( controlArray1, 3, false ) );
bufferGeometry.setAttribute( 'direction', new BufferAttribute( directionArray, 3, false ) );
}
return object3d;
}
//
class LDrawLoader extends Loader {
constructor( manager ) {
super( manager );
// Array of THREE.Material
this.materials = [];
// Not using THREE.Cache here because it returns the previous HTML error response instead of calling onError()
// This also allows to handle the embedded text files ("0 FILE" lines)
this.cache = new LDrawFileCache( this );
// This object is a map from file names to paths. It agilizes the paths search. If it is not set then files will be searched by trial and error.
this.fileMap = {};
this.rootParseScope = this.newParseScopeLevel();
// Add default main triangle and line edge materials (used in pieces that can be coloured with a main color)
this.setMaterials( [
this.parseColourMetaDirective( new LineParser( 'Main_Colour CODE 16 VALUE #FF8080 EDGE #333333' ) ),
this.parseColourMetaDirective( new LineParser( 'Edge_Colour CODE 24 VALUE #A0A0A0 EDGE #333333' ) )
] );
// If this flag is set to true the vertex normals will be smoothed.
this.smoothNormals = true;
// The path to load parts from the LDraw parts library from.
this.partsLibraryPath = '';
}
setPartsLibraryPath( path ) {
this.partsLibraryPath = path;
return this;
}
async preloadMaterials( url ) {
const fileLoader = new FileLoader( this.manager );
fileLoader.setPath( this.path );
fileLoader.setRequestHeader( this.requestHeader );
fileLoader.setWithCredentials( this.withCredentials );
const text = await fileLoader.loadAsync( url );
const colorLineRegex = /^0 !COLOUR/;
const lines = text.split( /[\n\r]/g );
const materials = [];
for ( let i = 0, l = lines.length; i < l; i ++ ) {
const line = lines[ i ];
if ( colorLineRegex.test( line ) ) {
const directive = line.replace( colorLineRegex, '' );
const material = this.parseColourMetaDirective( new LineParser( directive ) );
materials.push( material );
}
}
this.setMaterials( materials );
}
load( url, onLoad, onProgress, onError ) {
const fileLoader = new FileLoader( this.manager );
fileLoader.setPath( this.path );
fileLoader.setRequestHeader( this.requestHeader );
fileLoader.setWithCredentials( this.withCredentials );
fileLoader.load( url, text => {
this.processObject( text, null, url, this.rootParseScope )
.then( function ( result ) {
onLoad( result.groupObject );
} );
}, onProgress, onError );
}
parse( text, path, onLoad ) {
// Async parse. This function calls onParse with the parsed THREE.Object3D as parameter
this.processObject( text, null, path, this.rootParseScope )
.then( function ( result ) {
onLoad( result.groupObject );
} );
}
setMaterials( materials ) {
// Clears parse scopes stack, adds new scope with material library
this.rootParseScope = this.newParseScopeLevel( materials );
this.rootParseScope.isFromParse = false;
this.materials = materials;
return this;
}
setFileMap( fileMap ) {
this.fileMap = fileMap;
return this;
}
newParseScopeLevel( materials = null, parentScope = null ) {
// Adds a new scope level, assign materials to it and returns it
const matLib = {};
if ( materials ) {
for ( let i = 0, n = materials.length; i < n; i ++ ) {
const material = materials[ i ];
matLib[ material.userData.code ] = material;
}
}
const newParseScope = {
parentScope: parentScope,
lib: matLib,
url: null,
// Subobjects
subobjects: null,
numSubobjects: 0,
subobjectIndex: 0,
inverted: false,
category: null,
keywords: null,
// Current subobject
currentFileName: null,
mainColourCode: parentScope ? parentScope.mainColourCode : '16',
mainEdgeColourCode: parentScope ? parentScope.mainEdgeColourCode : '24',
matrix: new Matrix4(),
type: 'Model',
groupObject: null,
// If false, it is a root material scope previous to parse
isFromParse: true,
faces: [],
lineSegments: [],
conditionalSegments: [],
totalFaces: 0,
faceMaterials: new Set(),
// If true, this object is the start of a construction step
startingConstructionStep: false
};
return newParseScope;
}
addMaterial( material, parseScope ) {
// Adds a material to the material library which is on top of the parse scopes stack. And also to the materials array
const matLib = parseScope.lib;
if ( ! matLib[ material.userData.code ] ) {
this.materials.push( material );
}
matLib[ material.userData.code ] = material;
return this;
}
getMaterial( colourCode, parseScope = this.rootParseScope ) {
// Given a colour code search its material in the parse scopes stack
if ( colourCode.startsWith( '0x2' ) ) {
// Special 'direct' material value (RGB colour)
const colour = colourCode.substring( 3 );
return this.parseColourMetaDirective( new LineParser( 'Direct_Color_' + colour + ' CODE -1 VALUE #' + colour + ' EDGE #' + colour + '' ) );
}
while ( parseScope ) {
const material = parseScope.lib[ colourCode ];
if ( material ) {
return material;
} else {
parseScope = parseScope.parentScope;
}
}
// Material was not found
return null;
}
parseColourMetaDirective( lineParser ) {
// Parses a colour definition and returns a THREE.Material
let code = null;
// Triangle and line colours
let colour = 0xFF00FF;
let edgeColour = 0xFF00FF;
// Transparency
let alpha = 1;
let isTransparent = false;
// Self-illumination:
let luminance = 0;
let finishType = FINISH_TYPE_DEFAULT;
let edgeMaterial = null;
const name = lineParser.getToken();
if ( ! name ) {
throw new Error( 'LDrawLoader: Material name was expected after "!COLOUR tag' + lineParser.getLineNumberString() + '.' );
}
// Parse tag tokens and their parameters
let token = null;
while ( true ) {
token = lineParser.getToken();
if ( ! token ) {
break;
}
switch ( token.toUpperCase() ) {
case 'CODE':
code = lineParser.getToken();
break;
case 'VALUE':
colour = lineParser.getToken();
if ( colour.startsWith( '0x' ) ) {
colour = '#' + colour.substring( 2 );
} else if ( ! colour.startsWith( '#' ) ) {
throw new Error( 'LDrawLoader: Invalid colour while parsing material' + lineParser.getLineNumberString() + '.' );
}
break;
case 'EDGE':
edgeColour = lineParser.getToken();
if ( edgeColour.startsWith( '0x' ) ) {
edgeColour = '#' + edgeColour.substring( 2 );
} else if ( ! edgeColour.startsWith( '#' ) ) {
// Try to see if edge colour is a colour code
edgeMaterial = this.getMaterial( edgeColour );
if ( ! edgeMaterial ) {
throw new Error( 'LDrawLoader: Invalid edge colour while parsing material' + lineParser.getLineNumberString() + '.' );
}
// Get the edge material for this triangle material
edgeMaterial = edgeMaterial.userData.edgeMaterial;
}
break;
case 'ALPHA':
alpha = parseInt( lineParser.getToken() );
if ( isNaN( alpha ) ) {
throw new Error( 'LDrawLoader: Invalid alpha value in material definition' + lineParser.getLineNumberString() + '.' );
}
alpha = Math.max( 0, Math.min( 1, alpha / 255 ) );
if ( alpha < 1 ) {
isTransparent = true;
}
break;
case 'LUMINANCE':
luminance = parseInt( lineParser.getToken() );
if ( isNaN( luminance ) ) {
throw new Error( 'LDrawLoader: Invalid luminance value in material definition' + LineParser.getLineNumberString() + '.' );
}
luminance = Math.max( 0, Math.min( 1, luminance / 255 ) );
break;
case 'CHROME':
finishType = FINISH_TYPE_CHROME;
break;
case 'PEARLESCENT':
finishType = FINISH_TYPE_PEARLESCENT;
break;
case 'RUBBER':
finishType = FINISH_TYPE_RUBBER;
break;
case 'MATTE_METALLIC':
finishType = FINISH_TYPE_MATTE_METALLIC;
break;
case 'METAL':
finishType = FINISH_TYPE_METAL;
break;
case 'MATERIAL':
// Not implemented
lineParser.setToEnd();
break;
default:
throw new Error( 'LDrawLoader: Unknown token "' + token + '" while parsing material' + lineParser.getLineNumberString() + '.' );
}
}
let material = null;
switch ( finishType ) {
case FINISH_TYPE_DEFAULT:
material = new MeshStandardMaterial( { color: colour, roughness: 0.3, metalness: 0 } );
break;
case FINISH_TYPE_PEARLESCENT:
// Try to imitate pearlescency by making the surface glossy
material = new MeshStandardMaterial( { color: colour, roughness: 0.3, metalness: 0.25 } );
break;
case FINISH_TYPE_CHROME:
// Mirror finish surface
material = new MeshStandardMaterial( { color: colour, roughness: 0, metalness: 1 } );
break;
case FINISH_TYPE_RUBBER:
// Rubber finish
material = new MeshStandardMaterial( { color: colour, roughness: 0.9, metalness: 0 } );
break;
case FINISH_TYPE_MATTE_METALLIC:
// Brushed metal finish
material = new MeshStandardMaterial( { color: colour, roughness: 0.8, metalness: 0.4 } );
break;
case FINISH_TYPE_METAL:
// Average metal finish
material = new MeshStandardMaterial( { color: colour, roughness: 0.2, metalness: 0.85 } );
break;
default:
// Should not happen
break;
}
material.transparent = isTransparent;
material.premultipliedAlpha = true;
material.opacity = alpha;
material.depthWrite = ! isTransparent;
material.polygonOffset = true;
material.polygonOffsetFactor = 1;
if ( luminance !== 0 ) {
material.emissive.set( material.color ).multiplyScalar( luminance );
}
if ( ! edgeMaterial ) {
// This is the material used for edges
edgeMaterial = new LineBasicMaterial( {
color: edgeColour,
transparent: isTransparent,
opacity: alpha,
depthWrite: ! isTransparent
} );
edgeMaterial.userData.code = code;
edgeMaterial.name = name + ' - Edge';
// This is the material used for conditional edges
edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
fog: true,
transparent: isTransparent,
depthWrite: ! isTransparent,
color: edgeColour,
opacity: alpha,
} );
}
material.userData.code = code;
material.name = name;
material.userData.edgeMaterial = edgeMaterial;
return material;
}
//
objectParse( text, parseScope ) {
// Retrieve data from the parent parse scope
const currentParseScope = parseScope;
const parentParseScope = currentParseScope.parentScope;
// Main colour codes passed to this subobject (or default codes 16 and 24 if it is the root object)
const mainColourCode = currentParseScope.mainColourCode;
const mainEdgeColourCode = currentParseScope.mainEdgeColourCode;
// Parse result variables
let faces;
let lineSegments;
let conditionalSegments;
const subobjects = [];
let category = null;
let keywords = null;
if ( text.indexOf( '\r\n' ) !== - 1 ) {
// This is faster than String.split with regex that splits on both
text = text.replace( /\r\n/g, '\n' );
}
const lines = text.split( '\n' );
const numLines = lines.length;
let parsingEmbeddedFiles = false;
let currentEmbeddedFileName = null;
let currentEmbeddedText = null;
let bfcCertified = false;
let bfcCCW = true;
let bfcInverted = false;
let bfcCull = true;
let type = '';
let startingConstructionStep = false;
const parseColourCode = ( lineParser, forEdge ) => {
// Parses next colour code and returns a THREE.Material
let colourCode = lineParser.getToken();
if ( ! forEdge && colourCode === '16' ) {
colourCode = mainColourCode;
}
if ( forEdge && colourCode === '24' ) {
colourCode = mainEdgeColourCode;
}
const material = this.getMaterial( colourCode, currentParseScope );
if ( ! material ) {
throw new Error( 'LDrawLoader: Unknown colour code "' + colourCode + '" is used' + lineParser.getLineNumberString() + ' but it was not defined previously.' );
}
return material;
};
// Parse all line commands
for ( let lineIndex = 0; lineIndex < numLines; lineIndex ++ ) {
const line = lines[ lineIndex ];
if ( line.length === 0 ) continue;
if ( parsingEmbeddedFiles ) {
if ( line.startsWith( '0 FILE ' ) ) {
// Save previous embedded file in the cache
this.cache.setData( currentEmbeddedFileName.toLowerCase(), currentEmbeddedText );
// New embedded text file
currentEmbeddedFileName = line.substring( 7 );
currentEmbeddedText = '';
} else {
currentEmbeddedText += line + '\n';
}
continue;
}
const lp = new LineParser( line, lineIndex + 1 );
lp.seekNonSpace();
if ( lp.isAtTheEnd() ) {
// Empty line
continue;
}
// Parse the line type
const lineType = lp.getToken();
let material;
let segment;
let inverted;
let ccw;
let doubleSided;
let v0, v1, v2, v3, c0, c1;
switch ( lineType ) {
// Line type 0: Comment or META
case '0':
// Parse meta directive
const meta = lp.getToken();
if ( meta ) {
switch ( meta ) {
case '!LDRAW_ORG':
type = lp.getToken();
currentParseScope.type = type;
faces = currentParseScope.faces;
lineSegments = currentParseScope.lineSegments;
conditionalSegments = currentParseScope.conditionalSegments;
break;
case '!COLOUR':
material = this.parseColourMetaDirective( lp );
if ( material ) {
this.addMaterial( material, parseScope );
} else {
console.warn( 'LDrawLoader: Error parsing material' + lp.getLineNumberString() );
}
break;
case '!CATEGORY':
category = lp.getToken();
break;
case '!KEYWORDS':
const newKeywords = lp.getRemainingString().split( ',' );
if ( newKeywords.length > 0 ) {
if ( ! keywords ) {
keywords = [];
}
newKeywords.forEach( function ( keyword ) {
keywords.push( keyword.trim() );
} );
}
break;
case 'FILE':
if ( lineIndex > 0 ) {
// Start embedded text files parsing
parsingEmbeddedFiles = true;
currentEmbeddedFileName = lp.getRemainingString();
currentEmbeddedText = '';
bfcCertified = false;
bfcCCW = true;
}
break;
case 'BFC':
// Changes to the backface culling state
while ( ! lp.isAtTheEnd() ) {
const token = lp.getToken();
switch ( token ) {
case 'CERTIFY':
case 'NOCERTIFY':
bfcCertified = token === 'CERTIFY';
bfcCCW = true;
break;
case 'CW':
case 'CCW':
bfcCCW = token === 'CCW';
break;
case 'INVERTNEXT':
bfcInverted = true;
break;
case 'CLIP':
case 'NOCLIP':
bfcCull = token === 'CLIP';
break;
default:
console.warn( 'THREE.LDrawLoader: BFC directive "' + token + '" is unknown.' );
break;
}
}
break;
case 'STEP':
startingConstructionStep = true;
break;
default:
// Other meta directives are not implemented
break;
}
}
break;
// Line type 1: Sub-object file
case '1':
material = parseColourCode( lp );
const posX = parseFloat( lp.getToken() );
const posY = parseFloat( lp.getToken() );
const posZ = parseFloat( lp.getToken() );
const m0 = parseFloat( lp.getToken() );
const m1 = parseFloat( lp.getToken() );
const m2 = parseFloat( lp.getToken() );
const m3 = parseFloat( lp.getToken() );
const m4 = parseFloat( lp.getToken() );
const m5 = parseFloat( lp.getToken() );
const m6 = parseFloat( lp.getToken() );
const m7 = parseFloat( lp.getToken() );
const m8 = parseFloat( lp.getToken() );
const matrix = new Matrix4().set(
m0, m1, m2, posX,
m3, m4, m5, posY,
m6, m7, m8, posZ,
0, 0, 0, 1
);
let fileName = lp.getRemainingString().trim().replace( /\\/g, '/' );
if ( this.fileMap[ fileName ] ) {
// Found the subobject path in the preloaded file path map
fileName = this.fileMap[ fileName ];
} else {
// Standardized subfolders
if ( fileName.startsWith( 's/' ) ) {
fileName = 'parts/' + fileName;
} else if ( fileName.startsWith( '48/' ) ) {
fileName = 'p/' + fileName;
}
}
subobjects.push( {
material: material,
matrix: matrix,
fileName: fileName,
inverted: bfcInverted !== currentParseScope.inverted,
startingConstructionStep: startingConstructionStep
} );
bfcInverted = false;
break;
// Line type 2: Line segment
case '2':
material = parseColourCode( lp, true );
v0 = lp.getVector();
v1 = lp.getVector();
segment = {
material: material.userData.edgeMaterial,
colourCode: material.userData.code,
v0: v0,
v1: v1,
vertices: [ v0, v1 ],
};
lineSegments.push( segment );
break;
// Line type 5: Conditional Line segment
case '5':
material = parseColourCode( lp, true );
v0 = lp.getVector();
v1 = lp.getVector();
c0 = lp.getVector();
c1 = lp.getVector();
segment = {
material: material.userData.edgeMaterial.userData.conditionalEdgeMaterial,
colourCode: material.userData.code,
vertices: [ v0, v1 ],
controlPoints: [ c0, c1 ],
};
conditionalSegments.push( segment );
break;
// Line type 3: Triangle
case '3':
material = parseColourCode( lp );
inverted = currentParseScope.inverted;
ccw = bfcCCW !== inverted;
doubleSided = ! bfcCertified || ! bfcCull;
if ( ccw === true ) {
v0 = lp.getVector();
v1 = lp.getVector();
v2 = lp.getVector();
} else {
v2 = lp.getVector();
v1 = lp.getVector();
v0 = lp.getVector();
}
faces.push( {
material: material,
colourCode: material.userData.code,
faceNormal: null,
vertices: [ v0, v1, v2 ],
normals: [ null, null, null ],
} );
currentParseScope.totalFaces ++;
if ( doubleSided === true ) {
faces.push( {
material: material,
colourCode: material.userData.code,
faceNormal: null,
vertices: [ v2, v1, v0 ],
normals: [ null, null, null ],
} );
currentParseScope.totalFaces ++;
}
currentParseScope.faceMaterials.add( material );
break;
// Line type 4: Quadrilateral
case '4':
material = parseColourCode( lp );
inverted = currentParseScope.inverted;
ccw = bfcCCW !== inverted;
doubleSided = ! bfcCertified || ! bfcCull;
if ( ccw === true ) {
v0 = lp.getVector();
v1 = lp.getVector();
v2 = lp.getVector();
v3 = lp.getVector();
} else {
v3 = lp.getVector();
v2 = lp.getVector();
v1 = lp.getVector();
v0 = lp.getVector();
}
// specifically place the triangle diagonal in the v0 and v1 slots so we can
// account for the doubling of vertices later when smoothing normals.
faces.push( {
material: material,
colourCode: material.userData.code,
faceNormal: null,
vertices: [ v0, v1, v2, v3 ],
normals: [ null, null, null, null ],
} );
currentParseScope.totalFaces += 2;
if ( doubleSided === true ) {
faces.push( {
material: material,
colourCode: material.userData.code,
faceNormal: null,
vertices: [ v3, v2, v1, v0 ],
normals: [ null, null, null, null ],
} );
currentParseScope.totalFaces += 2;
}
break;
default:
throw new Error( 'LDrawLoader: Unknown line type "' + lineType + '"' + lp.getLineNumberString() + '.' );
}
}
if ( parsingEmbeddedFiles ) {
this.cache.setData( currentEmbeddedFileName.toLowerCase(), currentEmbeddedText );
}
currentParseScope.category = category;
currentParseScope.keywords = keywords;
currentParseScope.subobjects = subobjects;
currentParseScope.numSubobjects = subobjects.length;
currentParseScope.subobjectIndex = 0;
const isRoot = ! parentParseScope.isFromParse;
if ( isRoot || ! isPrimitiveType( type ) ) {
currentParseScope.groupObject = new Group();
currentParseScope.groupObject.userData.startingConstructionStep = currentParseScope.startingConstructionStep;
}
}
computeConstructionSteps( model ) {
// Sets userdata.constructionStep number in Group objects and userData.numConstructionSteps number in the root Group object.
let stepNumber = 0;
model.traverse( c => {
if ( c.isGroup ) {
if ( c.userData.startingConstructionStep ) {
stepNumber ++;
}
c.userData.constructionStep = stepNumber;
}
} );
model.userData.numConstructionSteps = stepNumber + 1;
}
finalizeObject( subobjectParseScope ) {
// fail gracefully if an object could not be loaded
if ( subobjectParseScope === null ) {
return;
}
const parentParseScope = subobjectParseScope.parentScope;
// Smooth the normals if this is a part or if this is a case where the subpart
// is added directly into the parent model (meaning it will never get smoothed by
// being added to a part)
const doSmooth =
isPartType( subobjectParseScope.type ) ||
(
isPrimitiveType( subobjectParseScope.type ) &&
isModelType( subobjectParseScope.parentScope.type )
);
if ( this.smoothNormals && doSmooth ) {
generateFaceNormals( subobjectParseScope.faces );
// only check subsetgments if we have multiple materials in a single part because this seems to be the case where it's needed most --
// there may be cases where a single edge line crosses over polygon edges that are broken up by multiple materials.
const checkSubSegments = subobjectParseScope.faceMaterials.size > 1;
smoothNormals( subobjectParseScope.faces, subobjectParseScope.lineSegments, checkSubSegments );
}
const isRoot = ! parentParseScope.isFromParse;
if ( ! isPrimitiveType( subobjectParseScope.type ) || isRoot ) {
const objGroup = subobjectParseScope.groupObject;
if ( subobjectParseScope.faces.length > 0 ) {
objGroup.add( createObject( subobjectParseScope.faces, 3, false, subobjectParseScope.totalFaces ) );
}
if ( subobjectParseScope.lineSegments.length > 0 ) {
objGroup.add( createObject( subobjectParseScope.lineSegments, 2 ) );
}
if ( subobjectParseScope.conditionalSegments.length > 0 ) {
objGroup.add( createObject( subobjectParseScope.conditionalSegments, 2, true ) );
}
if ( parentParseScope.groupObject ) {
objGroup.name = subobjectParseScope.fileName;
objGroup.userData.category = subobjectParseScope.category;
objGroup.userData.keywords = subobjectParseScope.keywords;
subobjectParseScope.matrix.decompose( objGroup.position, objGroup.quaternion, objGroup.scale );
parentParseScope.groupObject.add( objGroup );
}
} else {
const parentLineSegments = parentParseScope.lineSegments;
const parentConditionalSegments = parentParseScope.conditionalSegments;
const parentFaces = parentParseScope.faces;
const parentFaceMaterials = parentParseScope.faceMaterials;
const lineSegments = subobjectParseScope.lineSegments;
const conditionalSegments = subobjectParseScope.conditionalSegments;
const faces = subobjectParseScope.faces;
const faceMaterials = subobjectParseScope.faceMaterials;
const matrix = subobjectParseScope.matrix;
const matrixScaleInverted = matrix.determinant() < 0;
for ( let i = 0, l = lineSegments.length; i < l; i ++ ) {
const ls = lineSegments[ i ];
const vertices = ls.vertices;
vertices[ 0 ].applyMatrix4( matrix );
vertices[ 1 ].applyMatrix4( matrix );
parentLineSegments.push( ls );
}
for ( let i = 0, l = conditionalSegments.length; i < l; i ++ ) {
const os = conditionalSegments[ i ];
const vertices = os.vertices;
const controlPoints = os.controlPoints;
vertices[ 0 ].applyMatrix4( matrix );
vertices[ 1 ].applyMatrix4( matrix );
controlPoints[ 0 ].applyMatrix4( matrix );
controlPoints[ 1 ].applyMatrix4( matrix );
parentConditionalSegments.push( os );
}
for ( let i = 0, l = faces.length; i < l; i ++ ) {
const tri = faces[ i ];
const vertices = tri.vertices;
for ( let i = 0, l = vertices.length; i < l; i ++ ) {
vertices[ i ].applyMatrix4( matrix );
}
// If the scale of the object is negated then the triangle winding order
// needs to be flipped.
if ( matrixScaleInverted ) {
vertices.reverse();
}
parentFaces.push( tri );
}
parentParseScope.totalFaces += subobjectParseScope.totalFaces;
faceMaterials.forEach( material => parentFaceMaterials.add( material ) );
}
}
async processObject( text, subobject, url, parentScope ) {
const scope = this;
const parseScope = this.newParseScopeLevel( null, parentScope );
parseScope.url = url;
const parentParseScope = parseScope.parentScope;
// Set current matrix
if ( subobject ) {
parseScope.matrix.copy( subobject.matrix );
parseScope.inverted = subobject.inverted;
parseScope.startingConstructionStep = subobject.startingConstructionStep;
parseScope.mainColourCode = subobject.material.userData.code;
parseScope.mainEdgeColourCode = subobject.material.userData.edgeMaterial.userData.code;
parseScope.fileName = subobject.fileName;
}
// Parse the object
this.objectParse( text, parseScope );
const subobjects = parseScope.subobjects;
const promises = [];
for ( let i = 0, l = subobjects.length; i < l; i ++ ) {
promises.push( loadSubobject( parseScope.subobjects[ i ] ) );
}
// Kick off of the downloads in parallel but process all the subobjects
// in order so all the assembly instructions are correct
const subobjectScopes = await Promise.all( promises );
for ( let i = 0, l = subobjectScopes.length; i < l; i ++ ) {
this.finalizeObject( subobjectScopes[ i ] );
}
// If it is root object then finalize this object and compute construction steps
if ( ! parentParseScope.isFromParse ) {
this.finalizeObject( parseScope );
this.computeConstructionSteps( parseScope.groupObject );
}
return parseScope;
function loadSubobject( subobject ) {
return scope.cache.loadData( subobject.fileName ).then( function ( text ) {
return scope.processObject( text, subobject, url, parseScope );
} ).catch( function ( err ) {
console.warn( 'LDrawLoader: Subobject "' + subobject.fileName + '" could not be loaded.' );
console.warn( err );
return null;
} );
}
}
}
export { LDrawLoader };
| gero3/three.js | examples/jsm/loaders/LDrawLoader.js | JavaScript | mit | 48,722 |