code stringlengths 2 1.05M |
|---|
"use strict";
var crypto = require("crypto");
var util = require("util");
var EventEmitter = require("events").EventEmitter;
var router = require("easy-router");
var webSocketCollector = [];
router.setMap("wsindex", "websocket/client.html");
function WebSocket(socket) {
this.state = "OPEN";
this.pingTimes = 0;
this.socket = socket;
this.datas = [];
this.bind();
this.checkHeartBeat();
}
util.inherits(WebSocket, EventEmitter);
WebSocket.prototype.bind = function() {
var that = this;
this.socket.on('data', function(data) {
that.dataHandle(data);
});
this.socket.on('close', function(e) {
that.close(e);
});
this.socket.on('error', function(e) {
that.close(e);
});
};
//获取数据信息
WebSocket.prototype.handleDataStat = function(data) {
if (!this.stat) {
var dataIndex = 2; //数据索引，因为第一个字节和第二个字节肯定不为数据，所以初始值为2
var secondByte = data[1]; //代表masked位和可能是payloadLength位的第二个字节
var hasMask = secondByte >= 128; //如果大于或等于128，说明masked位为1
secondByte -= hasMask ? 128 : 0; //如果有掩码，需要将掩码那一位去掉
var dataLength, maskedData;
//如果为126，则后面16位长的数据为数据长度，如果为127，则后面64位长的数据为数据长度
if (secondByte == 126) {
dataIndex += 2;
dataLength = data.readUInt16BE(2);
} else if (secondByte == 127) {
dataIndex += 8;
dataLength = data.readUInt32BE(2) + data.readUInt32BE(6);
} else {
dataLength = secondByte;
}
//如果有掩码，则获取32位的二进制masking key，同时更新index
if (hasMask) {
maskedData = data.slice(dataIndex, dataIndex + 4);
dataIndex += 4;
}
//数据量最大为10kb
if (dataLength > 10240) {
this.send("Warning : data limit 10kb");
} else {
//计算到此处时，dataIndex为数据位的起始位置，dataLength为数据长度，maskedData为二进制的解密数据
this.stat = {
index: dataIndex,
totalLength: dataLength,
length: dataLength,
maskedData: maskedData,
opcode: parseInt(data[0].toString(16).split("")[1], 16) //获取第一个字节的opcode位
};
}
} else {
this.stat.index = 0;
}
};
//解析数据
WebSocket.prototype.dataHandle = function(data) {
this.handleDataStat(data);
var stat;
if (!(stat = this.stat)) return;
//如果opcode为9，则发送pong响应，如果opcode为10则置pingtimes为0
if (stat.opcode === 9 || stat.opcode === 10) {
(stat.opcode === 9) ? (this.sendPong()) : (this.pingTimes = 0);
this.reset();
return;
}
var result;
if (stat.maskedData) {
result = new Buffer(data.length - stat.index);
for (var i = stat.index, j = 0; i < data.length; i++, j++) {
//对每个字节进行异或运算，masked是4个字节，所以%4，借此循环
result[j] = data[i] ^ stat.maskedData[j % 4];
}
} else {
result = data.slice(stat.index, data.length);
}
this.datas.push(result);
stat.length -= (data.length - stat.index);
//当长度为0，说明当前帧为最后帧
if (stat.length == 0) {
var buf = Buffer.concat(this.datas, stat.totalLength);
if (stat.opcode == 8) {
this.close(buf.toString());
} else {
this.emit("message", buf.toString());
}
this.reset();
}
};
WebSocket.prototype.reset = function() {
this.stat = null;
this.datas.length = 0;
};
WebSocket.prototype.close = function(reason) {
this.emit('close', reason);
this.state = "CLOSE";
this.socket.destroy();
var index = webSocketCollector.indexOf(this);
if (index >= 0) {
webSocketCollector.splice(index, 1);
brocast("man:" + webSocketCollector.length);
}
};
//每隔10秒进行一次心跳检测，若连续发出三次心跳却没收到响应则关闭socket
WebSocket.prototype.checkHeartBeat = function() {
var that = this;
setTimeout(function() {
if (that.state !== "OPEN") return;
if (that.pingTimes >= 3) {
that.close("time out");
return;
}
//记录心跳次数
that.pingTimes++;
that.sendPing();
that.checkHeartBeat();
}, 10000);
};
WebSocket.prototype.sendPing = function() {
this.socket.write(new Buffer(['0x89', '0x0']))
};
WebSocket.prototype.sendPong = function() {
this.socket.write(new Buffer(['0x8A', '0x0']))
};
//数据发送
WebSocket.prototype.send = function(message) {
if (this.state !== "OPEN" && this.socket.writable) return;
message = String(message);
var length = Buffer.byteLength(message);
//数据的起始位置，如果数据长度16位也无法描述，则用64位，即8字节，如果16位能描述则用2字节，否则用第二个字节描述
var index = 2 + (length > 65535 ? 8 : (length > 125 ? 2 : 0));
//定义buffer，长度为描述字节长度 + message长度
var buffer = new Buffer(index + length);
//第一个字节，fin位为1，opcode为1
buffer[0] = 129;
//因为是由服务端发至客户端，所以无需masked掩码
if (length > 65535) {
buffer[1] = 127;
//长度超过65535的则由8个字节表示，因为4个字节能表达的长度为4294967295，已经完全够用，因此直接将前面4个字节置0
buffer.writeUInt32BE(0, 2);
buffer.writeUInt32BE(length, 6);
} else if (length > 125) {
buffer[1] = 126;
//长度超过125的话就由2个字节表示
buffer.writeUInt16BE(length, 2);
} else {
buffer[1] = length;
}
//写入正文
buffer.write(message, index);
this.socket.write(buffer);
};
function brocast(msg) {
webSocketCollector.forEach(function(ws) {
if (ws && ws.state == "OPEN") {
ws.send(msg);
}
})
}
module.exports = {
getList: function() {
return webSocketCollector.slice(0);
},
brocast: function(msg) {
brocast(msg)
},
upgrad: function(server, callback) {
server.on('upgrade', function(req, socket, upgradeHead) {
var key = req.headers['sec-websocket-key'];
key = crypto.createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
var headers = [
'HTTP/1.1 101 Switching Protocols',
'Upgrade: websocket',
'Connection: Upgrade',
'Sec-WebSocket-Accept: ' + key
];
socket.setNoDelay(true);
socket.write(headers.join("\r\n") + "\r\n\r\n", 'ascii');
var ws = new WebSocket(socket);
webSocketCollector.push(ws);
brocast("man:" + webSocketCollector.length);
callback(ws);
});
}
}; |
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var pinterestP = exports.pinterestP = { "viewBox": "0 0 1280 1792", "children": [{ "name": "path", "attribs": { "d": "M0 597q0-108 37.5-203.5t103.5-166.5 152-123 185-78 202-26q158 0 294 66.5t221 193.5 85 287q0 96-19 188t-60 177-100 149.5-145 103-189 38.5q-68 0-135-32t-96-88q-10 39-28 112.5t-23.5 95-20.5 71-26 71-32 62.5-46 77.5-62 86.5l-14 5-9-10q-15-157-15-188 0-92 21.5-206.5t66.5-287.5 52-203q-32-65-32-169 0-83 52-156t132-73q61 0 95 40.5t34 102.5q0 66-44 191t-44 187q0 63 45 104.5t109 41.5q55 0 102-25t78.5-68 56-95 38-110.5 20-111 6.5-99.5q0-173-109.5-269.5t-285.5-96.5q-200 0-334 129.5t-134 328.5q0 44 12.5 85t27 65 27 45.5 12.5 30.5q0 28-15 73t-37 45q-2 0-17-3-51-15-90.5-56t-61-94.5-32.5-108-11-106.5z" } }] }; |
'use strict';
/* jshint ignore:start */
var expect = require('expect.js');
/* jshint ignore:end */
var Qty = require('../../qty');
describe('Charge' , function () {
it('should evaluate empty input as 0 coulomb', function () {
var zero = Qty.Charge();
expect(zero.value()).to.be(0);
expect(zero.isCharge()).to.be.ok();
});
it('should evaluate numerical input as coulomb', function () {
expect(Qty.Charge(1).toSI().value()).to.be(1);
});
describe('Centicoulomb', function () {
it('can be obtain from C', function () {
expect(Qty('1C').to('cC').value()).to.be(1e2);
});
it('can be converted to F', function () {
expect(Qty('1cC').toSI().value()).to.be(1e-2);
});
it('should be a charge', function () {
expect(Qty('1cC').isCharge()).to.be.ok();
});
});
});
|
var expect = require("chai").expect;
var tools = require("../lib/tools");
describe("Tools", function(){
describe("printName()", function() {
it("should print the last name first", function() {
var results = tools.printName({ first: "Alex", last: "Banks"});
expect(results).to.equal("Banks, Alex");
});
});
// Load wiki will open wiki page.
describe("loadWiki()", function(){
this.timeout(5000);
it("Load Abraham Lincoln's wikipedia page.", function(done){
tools.loadWiki({first: "Abraham", last: "Lincoln"}, function(html){
expect(html).to.be.ok;
done();
})
});
});
});
|
//= require jquery
//= require jquery_ujs
//= require jquery-ui
// Required by Blacklight
//= require blacklight/blacklight
//= require nyulibraries_javascripts/nyulibraries
//= require_tree .
|
/**
* @class Ext.ux.TreeCheckNodeUI
* @extends Ext.tree.TreeNodeUI
*
* 对 Ext.tree.TreeNodeUI 进行checkbox功能的扩展,后台返回的结点信息不用非要包含checked属性
*
* 扩展的功能点有：
* 一、支持只对树的叶子进行选择
* 只有当返回的树结点属性leaf = true 时，结点才有checkbox可选
* 使用时，只需在声明树时，加上属性 onlyLeafCheckable: true 既可，默认是false
*
* 二、支持对树的单选
* 只允许选择一个结点
* 使用时，只需在声明树时，加上属性 checkModel: "single" 既可
*
* 二、支持对树的级联多选
* 当选择结点时，自动选择该结点下的所有子结点，或该结点的所有父结点（根结点除外），特别是支持异步，当子结点还没显示时，会从后台取得子结点，然后将其选中/取消选中
* 使用时，只需在声明树时，加上属性 checkModel: "cascade" 或"parentCascade"或"childCascade"既可
*
* 三、添加"check"事件
* 该事件会在树结点的checkbox发生改变时触发
* 使用时，只需给树注册事件,如：
* tree.on("check",function(node,checked){...});
*
* 默认情况下，checkModel为'multiple'，也就是多选，onlyLeafCheckable为false，所有结点都可选
*
* 使用方法：在loader里加上 baseAttrs:{uiProvider:Ext.ux.TreeCheckNodeUI} 既可.
* 例如：
* var tree = new Ext.tree.TreePanel({
* el:'tree-ct',
* width:568,
* height:300,
* checkModel: 'cascade', //对树的级联多选
* onlyLeafCheckable: false,//对树所有结点都可选
* animate: false,
* rootVisible: false,
* autoScroll:true,
* loader: new Ext.tree.DWRTreeLoader({
* dwrCall:Tmplt.getTmpltTree,
* baseAttrs: { uiProvider: Ext.ux.TreeCheckNodeUI } //添加 uiProvider 属性
* }),
* root: new Ext.tree.AsyncTreeNode({ id:'0' })
* });
* tree.on("check",function(node,checked){alert(node.text+" = "+checked)}); //注册"check"事件
* tree.render();
*
*/
Ext.ux.TreeCheckNodeUI = function() {
//多选: 'multiple'(默认)
//单选: 'single'
//级联多选: 'cascade'(同时选父和子);'parentCascade'(选父);'childCascade'(选子)
this.checkModel = 'multiple';
//only leaf can checked
this.onlyLeafCheckable = false;
Ext.ux.TreeCheckNodeUI.superclass.constructor.apply(this, arguments);
};
Ext.extend(Ext.ux.TreeCheckNodeUI, Ext.tree.TreeNodeUI, {
renderElements : function(n, a, targetNode, bulkRender){
var tree = n.getOwnerTree();
this.checkModel = tree.checkModel || this.checkModel;
this.onlyLeafCheckable = tree.onlyLeafCheckable || false;
// add some indent caching, this helps performance when rendering a large tree
this.indentMarkup = n.parentNode ? n.parentNode.ui.getChildIndent() : '';
//var cb = typeof a.checked == 'boolean';
var cb = (!this.onlyLeafCheckable || a.leaf);
var href = a.href ? a.href : Ext.isGecko ? "" : "#";
var buf = ['<li class="x-tree-node"><div ext:tree-node-id="',n.id,'" class="x-tree-node-el x-tree-node-leaf x-unselectable ', a.cls,'" unselectable="on">',
'<span class="x-tree-node-indent">',this.indentMarkup,"</span>",
'<img src="', this.emptyIcon, '" class="x-tree-ec-icon x-tree-elbow" />',
'<img src="', a.icon || this.emptyIcon, '" class="x-tree-node-icon',(a.icon ? " x-tree-node-inline-icon" : ""),(a.iconCls ? " "+a.iconCls : ""),'" unselectable="on" />',
cb ? ('<input class="x-tree-node-cb" type="checkbox" ' + (a.checked ? 'checked="checked" />' : '/>')) : '',
'<a hidefocus="on" class="x-tree-node-anchor" href="',href,'" tabIndex="1" ',
a.hrefTarget ? ' target="'+a.hrefTarget+'"' : "", '><span unselectable="on">',n.text,"</span></a></div>",
'<ul class="x-tree-node-ct" style="display:none;"></ul>',
"</li>"].join('');
var nel;
if(bulkRender !== true && n.nextSibling && (nel = n.nextSibling.ui.getEl())){
this.wrap = Ext.DomHelper.insertHtml("beforeBegin", nel, buf);
}else{
this.wrap = Ext.DomHelper.insertHtml("beforeEnd", targetNode, buf);
}
this.elNode = this.wrap.childNodes[0];
this.ctNode = this.wrap.childNodes[1];
var cs = this.elNode.childNodes;
this.indentNode = cs[0];
this.ecNode = cs[1];
this.iconNode = cs[2];
var index = 3;
if(cb){
this.checkbox = cs[3];
Ext.fly(this.checkbox).on('click', this.check.createDelegate(this,[null]));
index++;
}
this.anchor = cs[index];
this.textNode = cs[index].firstChild;
},
// private
check : function(checked){
var n = this.node;
var tree = n.getOwnerTree();
this.checkModel = tree.checkModel || this.checkModel;
if( checked === null ) {
checked = this.checkbox.checked;
} else {
this.checkbox.checked = checked;
}
n.attributes.checked = checked;
tree.fireEvent('check', n, checked);
if(this.checkModel == 'single'){
var checkedNodes = tree.getChecked();
for(var i=0;i<checkedNodes.length;i++){
var node = checkedNodes[i];
node.getUI().checkbox.checked = false;
node.attributes.checked = false;
tree.fireEvent('check', node, false);
}
n.getUI().checkbox.checked = true;
n.attributes.checked = true;
tree.fireEvent('check', n, true);
} else if(!this.onlyLeafCheckable){
if(this.checkModel == 'cascade' || this.checkModel == 'parentCascade'){
var parentNode = n.parentNode;
if(parentNode !== null) {
this.parentCheck(parentNode,checked);
}
}
if(this.checkModel == 'cascade' || this.checkModel == 'childCascade'){
if( !n.expanded && !n.childrenRendered ) {
n.expand(false,false,this.childCheck);
}else {
this.childCheck(n);
}
}
}
},
// private
childCheck : function(node){
var a = node.attributes;
if(!a.leaf) {
var cs = node.childNodes;
var csui;
for(var i = 0; i < cs.length; i++) {
csui = cs[i].getUI();
if(csui.checkbox.checked ^ a.checked)
csui.check(a.checked);
}
}
},
// private
parentCheck : function(node ,checked){
var checkbox = node.getUI().checkbox;
if(typeof checkbox == 'undefined')return ;
if(!(checked ^ checkbox.checked))return;
if(!checked && this.childHasChecked(node))return;
checkbox.checked = checked;
node.attributes.checked = checked;
node.getOwnerTree().fireEvent('check', node, checked);
var parentNode = node.parentNode;
if( parentNode !== null){
this.parentCheck(parentNode,checked);
}
},
// private
childHasChecked : function(node){
var childNodes = node.childNodes;
if(childNodes || childNodes.length>0){
for(var i=0;i<childNodes.length;i++){
if(childNodes[i].getUI().checkbox.checked)
return true;
}
}
return false;
},
toggleCheck : function(value){
var cb = this.checkbox;
if(cb){
var checked = (value === undefined ? !cb.checked : value);
this.check(checked);
}
}
}); |
// Very small wrapper for getting a data URL
var DataWrapper = function () {
return {
get: function (file) {
return chrome.extension.getURL(file);
}
};
};
if(!xt) var xt = {};
xt.data = DataWrapper(); |
import React, { Component } from 'react';
import shouldPureComponentUpdate from 'react-pure-render/function';
import MobileSidebar from '../sidebar/MobileSidebar';
import MobileToolbarBtn from './MobileToolbarBtn';
export default class MobileToolbarFull extends Component {
shouldComponentUpdate = shouldPureComponentUpdate;
render() {
return (
<div className="mobile-toolbar">
<input id="hamburger-closer" type="radio" name="hamburger" defaultChecked />
<label id="hamburger-overlay" htmlFor="hamburger-closer"></label>
<input id="hamburger-opener" className="hamburger" type="radio" name="hamburger" />
<label id="hamburger-btn" htmlFor="hamburger-opener" className="toolbar-btn">
<img src="img/menu.svg" />
<MobileSidebar />
</label>
<MobileToolbarBtn to={'/'} img="img/trade.svg" />
<MobileToolbarBtn to={'/watchlist-mobile'} img="img/watchlist.svg" />
<MobileToolbarBtn to={'/portfolio-mobile'} img="img/portfolio.svg" />
<MobileToolbarBtn to={'/statement-mobile'} img="img/statement.svg" />
<MobileToolbarBtn to={'/news-mobile'} img="img/news.svg" />
<MobileToolbarBtn to={'/resources-mobile'} img="img/resources.svg" />
<MobileToolbarBtn to={'/settings-mobile'} img="img/settings.svg" />
</div>
);
}
}
|
var expect = require("chai").expect;
module.exports = function (helpers) {
var component = helpers.mount(require.resolve("./index"), {});
var els = component.getEls("colorListItems");
expect(els.length).to.equal(3);
expect(els[0].innerHTML).to.equal("red");
expect(els[1].innerHTML).to.equal("green");
expect(els[2].innerHTML).to.equal("blue");
};
|
/** A ChangesetDownloader downloads, parses, and stores the contents of a changeset.*/
var zlib = require('zlib'),
request = require('request'),
N3 = require('n3');
function ChangesetDownloader(options) {
}
ChangesetDownloader.prototype._parseFileFillTriples = function(input) {
input.triples = [];
var parser = N3.Parser(),
_this = this;
parser.parse(input._fileContents,
function(error,triple,prefixes) {
if(triple) input.triples.push(triple);
if(triple === null && _this._doneCallback) {
_this._doneCallback();
}
});
delete input._fileContents;
};
ChangesetDownloader.prototype.downloadAndParse = function(input,callback) {
var gunz = zlib.createGunzip(),
_this = this,
res = request(input.url).pipe(gunz);
input._fileContents = "";
res.on('error', function() {
console.log("Error downloading changeset - URL: "+input.url);
});
res.on('data',function(chunk){
input._fileContents += chunk;
});
res.on('end', function() {_this._parseFileFillTriples(input);
if(callback) callback();});
};
module.exports = ChangesetDownloader;
|
var fs = require('fs');
var path = require('path');
var async = require('async');
var connection = require('./connection.js');
var data = JSON.parse(fs.readFileSync(path.join(__dirname, 'database.json'), 'utf8'));
module.exports = exports = {
data: data,
setUp: function (cb) {
var docs = data;
if (docs && docs.length) {
connection.db.create(connection.TEST_DB_NAME, function () {
var db = connection.use(connection.TEST_DB_NAME);
async.forEach(docs, function (doc, done) {
db.insert(doc, function (err, body) {
var a = err ? done(err) : done();
});
}, function (err, body) {
if (err) { console.log(err); }
else { console.log("Set up."); }
cb && cb();
});
});
} else {
throw new Error('Data of the test db could not be read.');
}
},
tearDown: function (cb) {
connection.db.destroy(connection.TEST_DB_NAME, function (err, body) {
if (err) { console.log(err); }
else { console.log("Teared down."); }
cb && cb();
});
},
connection: connection
};
|
import React, {Component} from 'react'
import Header from '../Common/Header'
import {View, StyleSheet, ScrollView} from 'react-native'
import {Actions} from 'react-native-router-flux'
import * as Theme from '../../Theme'
import Button from '../Common/Button'
import MarkerView from '../Common/MarkerView'
import PropTypes from 'prop-types'
import {RegionShape, MarkerShape} from '../../Utils/PropTypeShapes'
import Container from '../Common/Container'
//Renders view for admin to manage a marker
//Admin can accept or reject the markers
//Edit button takes to EditMarker
export default class AdminMarkerViewComponent extends Component {
render() {
return (
<Container title="Confirm Marker" backButton>
<MarkerView
marker={this.props.marker}
currentRegion={this.props.currentRegion}
/>
<Button onPress={this.props.onAcceptClick}>
Accept
</Button>
<Button onPress={this.props.onRejectClick}>
Reject
</Button>
<Button onPress={this.props.onEditClick}>
Edit
</Button>
</Container>
)
}
}
const styles = StyleSheet.create({
container: {
flex: 1,
backgroundColor: Theme.backgroundColor
}
})
AdminMarkerViewComponent.propTypes = {
marker: MarkerShape,
currentRegion: RegionShape,
onAcceptClick:PropTypes.func,
onRejectClick:PropTypes.func,
onEditClick:PropTypes.func,
}
|
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* Route to handle root element: return uri's for available resources & note on authentication */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
'use strict';
let router = require('koa-router')(); // router middleware for koa
router.get('/', function* getRoot() {
// root element just returns uri's for principal resources (in preferred format)
let resources = { auth: {_uri: '/auth'}, members: {_uri: '/members'}, teams: {_uri: '/teams'} };
let authentication = '‘GET /auth’ to obtain {id, token}; subsequent requests require basic auth ‘id:token’';
this.body = { resources: resources, authentication: authentication };
this.body.root = 'api';
});
module.exports = router.middleware();
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
'use strict';
// Use Applicaion configuration module to register a new module
ApplicationConfiguration.registerModule('channels');
|
export const TRIP_QUERY_FROM = `FROM "Trip" t, "CheckIn" ci, "CheckIn" fci, "CheckIn" lci`;
export const TRIP_QUERY_WHERE = `
AND ci."userId" = t."userId"
AND fci.id = t."firstCheckInId"
AND lci.id = t."lastCheckInId"
AND ci."createdAt" BETWEEN fci."createdAt" AND lci."createdAt"
`;
export const OPEN_TRIP_QUERY_FROM = `FROM "Trip" t, "CheckIn" ci, "CheckIn" fci`;
export const OPEN_TRIP_QUERY_WHERE = `
AND ci."userId" = t."userId"
AND fci.id = t."firstCheckInId"
AND ci."createdAt" >= fci."createdAt"
`;
export const getTripQuery = (id, withPhotos) => {
return `
${TRIP_QUERY_FROM} ${withPhotos ? ', "Post" p, "MediaItem" mi' : ''}
WHERE t.id = ${id}
${TRIP_QUERY_WHERE}
${withPhotos ? 'AND p."checkInId" = ci.id AND mi."entityUuid" = p."uuid"::varchar' : ''}
`;
};
export const getOpenTripQuery = (id, withPhotos) => {
return `
${OPEN_TRIP_QUERY_FROM} ${withPhotos ? ', "Post" p, "MediaItem" mi' : ''}
WHERE t.id = ${id}
${OPEN_TRIP_QUERY_WHERE}
${withPhotos ? 'AND p."checkInId" = ci.id AND mi."entityUuid" = p."uuid"::varchar' : ''}
`;
};
|
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("react"));
else if(typeof define === 'function' && define.amd)
define(["react"], factory);
else if(typeof exports === 'object')
exports["ReactHtml5Video"] = factory(require("react"));
else
root["ReactHtml5Video"] = factory(root["React"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_68__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(1);
module.exports = __webpack_require__(21);
/***/ },
/* 1 */
/***/ function(module, exports) {
// removed by extract-text-webpack-plugin
/***/ },
/* 2 */,
/* 3 */,
/* 4 */,
/* 5 */,
/* 6 */,
/* 7 */,
/* 8 */,
/* 9 */,
/* 10 */,
/* 11 */,
/* 12 */,
/* 13 */,
/* 14 */,
/* 15 */,
/* 16 */,
/* 17 */,
/* 18 */,
/* 19 */,
/* 20 */,
/* 21 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _objectWithoutProperties = __webpack_require__(22)['default'];
var _extends = __webpack_require__(24)['default'];
var _Object$assign = __webpack_require__(25)['default'];
var _Object$keys = __webpack_require__(62)['default'];
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _overlayOverlay = __webpack_require__(69);
var _overlayOverlay2 = _interopRequireDefault(_overlayOverlay);
var _controlsControls = __webpack_require__(72);
var _controlsControls2 = _interopRequireDefault(_controlsControls);
var _controlsSeekSeek = __webpack_require__(74);
var _controlsSeekSeek2 = _interopRequireDefault(_controlsSeekSeek);
var _controlsPlayPlay = __webpack_require__(73);
var _controlsPlayPlay2 = _interopRequireDefault(_controlsPlayPlay);
var _controlsMuteMute = __webpack_require__(81);
var _controlsMuteMute2 = _interopRequireDefault(_controlsMuteMute);
var _controlsFullscreenFullscreen = __webpack_require__(83);
var _controlsFullscreenFullscreen2 = _interopRequireDefault(_controlsFullscreenFullscreen);
var _controlsTimeTime = __webpack_require__(82);
var _controlsTimeTime2 = _interopRequireDefault(_controlsTimeTime);
var _controlsSubtitlesSubtitles = __webpack_require__(84);
var _controlsSubtitlesSubtitles2 = _interopRequireDefault(_controlsSubtitlesSubtitles);
var _lodashThrottle = __webpack_require__(85);
var _lodashThrottle2 = _interopRequireDefault(_lodashThrottle);
var _assetsCopy = __webpack_require__(88);
var _assetsCopy2 = _interopRequireDefault(_assetsCopy);
var EVENTS = ['onAbort', 'onCanPlay', 'onCanPlayThrough', 'onDurationChange', 'onEmptied', 'onEncrypted', 'onEnded', 'onError', 'onLoadedData', 'onLoadedMetadata', 'onLoadStart', 'onPause', 'onPlay', 'onPlaying', 'onProgress', 'onRateChange', 'onSeeked', 'onSeeking', 'onStalled', 'onSuspend', 'onTimeUpdate', 'onVolumeChange', 'onWaiting'];
var Video = _react2['default'].createClass({
displayName: 'Video',
propTypes: {
// Non-standard props
copyKeys: _react2['default'].PropTypes.object,
children: _react2['default'].PropTypes.node,
className: _react2['default'].PropTypes.string,
// HTML5 Video standard attributes
autoPlay: _react2['default'].PropTypes.bool,
muted: _react2['default'].PropTypes.bool,
controls: _react2['default'].PropTypes.bool
},
getDefaultProps: function getDefaultProps() {
return {
copyKeys: _assetsCopy2['default']
};
},
getInitialState: function getInitialState() {
// Set state from props and always use these
// to check state of video as they will update
// on the video events. Changing this state however will not
// change the video. The API methods must be used.
return {
networkState: 0,
paused: !this.props.autoPlay,
muted: !!this.props.muted,
volume: 1,
playbackRate: 1,
error: false,
loading: false,
textTracks: {},
textTrackSelected: null
};
},
/**
* Creates a throttle update method.
* @return {undefined}
*/
componentWillMount: function componentWillMount() {
var _this = this;
this._updateStateFromVideo = (0, _lodashThrottle2['default'])(this.updateStateFromVideo, 100);
// Set up all React media events and call method
// on props if provided.
this.mediaEventProps = EVENTS.reduce(function (p, c) {
p[c] = function (e) {
if (c in _this.props && typeof _this.props[c] === 'function') {
// A prop exists for this mediaEvent, call it.
_this.props[c](e);
}
_this._updateStateFromVideo();
};
return p;
}, {});
},
/**
* Bind eventlisteners not supported by React's synthetic events
* https://facebook.github.io/react/docs/events.html
* @return {undefined}
*/
componentDidMount: function componentDidMount() {
// Listen to error of last source.
this.videoEl.children[this.videoEl.children.length - 1].addEventListener('error', this._updateStateFromVideo);
},
/**
* Removes event listeners bound outside of React's synthetic events
* @return {undefined}
*/
componentWillUnmount: function componentWillUnmount() {
// Remove event listener from video.
this.videoEl.children[this.videoEl.children.length - 1].removeEventListener('error', this._updateStateFromVideo);
// Cancel the throttled function from being called once
// the video has been unmounted.
// https://github.com/mderrick/react-html5video/issues/35
this._updateStateFromVideo.cancel();
},
/**
* Toggles the video to play and pause.
* @return {undefined}
*/
togglePlay: function togglePlay() {
if (this.state.paused) {
this.play();
} else {
this.pause();
}
},
/**
* Toggles the video to mute and unmute.
* @return {undefined}
*/
toggleMute: function toggleMute() {
if (this.state.muted) {
this.unmute();
} else {
this.mute();
}
},
/**
* Loads video.
* @return {undefined}
*/
load: function load() {
this.videoEl.load();
},
/**
* Sets the video to fullscreen.
* @return {undefined}
*/
fullscreen: function fullscreen() {
if (this.videoEl.requestFullscreen) {
this.videoEl.requestFullscreen();
} else if (this.videoEl.msRequestFullscreen) {
this.videoEl.msRequestFullscreen();
} else if (this.videoEl.mozRequestFullScreen) {
this.videoEl.mozRequestFullScreen();
} else if (this.videoEl.webkitRequestFullscreen) {
this.videoEl.webkitRequestFullscreen();
}
},
/**
* Plays the video.
* @return {undefined}
*/
play: function play() {
this.videoEl.play();
},
/**
* Pauses the video.
* @return {undefined}
*/
pause: function pause() {
this.videoEl.pause();
},
/**
* Unmutes video.
* @return {undefined}
*/
unmute: function unmute() {
this.videoEl.muted = false;
},
/**
* Mutes the video.
* @return {undefined}
*/
mute: function mute() {
this.videoEl.muted = true;
},
/**
* Seeks the video timeline.
* @param {number} time The value in seconds to seek to
* @param {bool} forceUpdate Forces a state update without waiting for
* throttled event.
* @return {undefined}
*/
seek: function seek(time, forceUpdate) {
this.videoEl.currentTime = time;
// In some use cases, we wish not to wait for `onSeeked` or `onSeeking`
// throttled event to update state so we force it. This is because
// this method is often triggered when dragging a bar and can feel janky.
// See https://github.com/mderrick/react-html5video/issues/43
if (forceUpdate) {
this.updateStateFromVideo();
}
},
/**
* Sets the video volume.
* @param {number} volume The volume level between 0 and 1.
* @param {bool} forceUpdate Forces a state update without waiting for
* throttled event.
* @return {undefined}
*/
setVolume: function setVolume(volume, forceUpdate) {
this.videoEl.volume = volume;
// In some use cases, we wish not to wait for `onVolumeChange`
// throttled event to update state so we force it. This is because
// this method is often triggered when dragging a bar and can feel janky.
// See https://github.com/mderrick/react-html5video/issues/43
if (forceUpdate) {
this.updateStateFromVideo();
}
},
/**
* Sets the video playback rate.
* @param {number} rate The playback rate (default 1.0).
* @return {undefined}
*/
setPlaybackRate: function setPlaybackRate(rate) {
this.videoEl.playbackRate = rate;
this.updateStateFromVideo();
},
/**
* Updates the React component state from the DOM video properties.
* This is where the magic happens.
* @return {undefined}
*/
updateStateFromVideo: function updateStateFromVideo() {
this.setState({
// Standard video properties
duration: this.videoEl.duration,
currentTime: this.videoEl.currentTime,
buffered: this.videoEl.buffered,
paused: this.videoEl.paused,
muted: this.videoEl.muted,
volume: this.videoEl.volume,
playbackRate: this.videoEl.playbackRate,
readyState: this.videoEl.readyState,
textTracks: this.videoEl.textTracks,
// Non-standard state computed from properties
percentageBuffered: this.videoEl.buffered.length && this.videoEl.buffered.end(this.videoEl.buffered.length - 1) / this.videoEl.duration * 100,
percentagePlayed: this.videoEl.currentTime / this.videoEl.duration * 100,
error: this.videoEl.networkState === this.videoEl.NETWORK_NO_SOURCE,
loading: this.videoEl.readyState < this.videoEl.HAVE_ENOUGH_DATA
});
},
/**
* Returns everything but 'source' nodes from children
* and extends props so all children have access to Video API and state.
* If there are no controls provided, returns default Controls.
* @return {Array.<ReactElement>} An array of components.
*/
renderControls: function renderControls() {
var extendedProps = _Object$assign({
// The public methods that all controls should be able to
// use.
togglePlay: this.togglePlay,
toggleMute: this.toggleMute,
play: this.play,
pause: this.pause,
mute: this.mute,
unmute: this.unmute,
seek: this.seek,
fullscreen: this.fullscreen,
setVolume: this.setVolume,
setPlaybackRate: this.setPlaybackRate,
setTextTrack: this.setTextTrack
}, this.state, { copyKeys: this.props.copyKeys });
var controls = _react2['default'].Children.map(this.props.children, function (child) {
if (child.type === 'source' || child.type === 'track') {
return void 0;
}
return _react2['default'].cloneElement(child, extendedProps);
});
if (!controls.length) {
controls = _react2['default'].createElement(
'div',
null,
_react2['default'].createElement(_overlayOverlay2['default'], extendedProps),
_react2['default'].createElement(_controlsControls2['default'], extendedProps)
);
}
return controls;
},
/**
* Returns video 'source' nodes from children.
* @return {Array.<ReactElement>} An array of components.
*/
renderSources: function renderSources() {
return _react2['default'].Children.map(this.props.children, function (child) {
if (child.type !== 'source') {
return void 0;
}
return child;
});
},
/**
* Returns video 'track' nodes from children.
* @return {Array.<ReactElement>} An array of components.
*/
renderTexttracks: function renderTexttracks() {
return _react2['default'].Children.map(this.props.children, function (child) {
if (child.type !== 'track') {
return void 0;
}
return child;
});
},
setTextTrack: function setTextTrack(key) {
// first turn all off
var textTracks = this.videoEl.textTracks;
_Object$keys(this.videoEl.textTracks).forEach(function (offKey) {
textTracks[offKey].mode = 'disabled';
});
if (key) {
this.videoEl.textTracks[key].mode = 'showing';
}
this.setState({
textTrackSelected: key
});
this.onBlur();
},
/**
* Gets the video class name based on its state
* @return {string} Class string
*/
getVideoClassName: function getVideoClassName() {
var className = this.props.className;
var classString = 'video';
if (this.state.error) {
classString += ' video--error';
} else if (this.state.loading) {
classString += ' video--loading';
} else if (this.state.paused) {
classString += ' video--paused';
} else {
classString += ' video--playing';
}
if (this.state.focused) {
classString += ' video--focused';
}
if (className) {
classString += ' ' + className;
}
return classString;
},
/**
* Sets state to show focused class on video player.
* @return {undefined}
*/
onFocus: function onFocus() {
this.setState({
focused: true
});
},
/**
* Sets state to not be focused to remove class form video
* player.
* @return {undefined}
*/
onBlur: function onBlur() {
this.setState({
focused: false
});
},
render: function render() {
var _this2 = this;
// If controls prop is provided remove it
// and use our own controls.
// Leave `copyKeys` here even though not used
// as per issue #36.
var _props = this.props;
var controls = _props.controls;
var copyKeys = _props.copyKeys;
var style = _props.style;
var otherProps = _objectWithoutProperties(_props, ['controls', 'copyKeys', 'style']);
return _react2['default'].createElement(
'div',
{ className: this.getVideoClassName(),
tabIndex: '0',
onFocus: this.onFocus,
onBlur: this.onBlur,
style: style },
_react2['default'].createElement(
'video',
_extends({}, otherProps, {
className: 'video__el',
ref: function (el) {
_this2.videoEl = el;
}
// We have throttled `_updateStateFromVideo` so listen to
// every available Media event that React allows and
// infer the Video state in that method from the Video properties.
}, this.mediaEventProps),
this.renderSources(),
this.renderTexttracks()
),
controls ? this.renderControls() : ''
);
}
});
exports['default'] = Video;
exports.Controls = _controlsControls2['default'];
exports.Seek = _controlsSeekSeek2['default'];
exports.Play = _controlsPlayPlay2['default'];
exports.Mute = _controlsMuteMute2['default'];
exports.Fullscreen = _controlsFullscreenFullscreen2['default'];
exports.Time = _controlsTimeTime2['default'];
exports.Overlay = _overlayOverlay2['default'];
exports.Subtitles = _controlsSubtitlesSubtitles2['default'];
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(23);
/***/ },
/* 23 */
/***/ function(module, exports) {
"use strict";
exports.__esModule = true;
exports.default = function (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;
};
/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
var _assign = __webpack_require__(25);
var _assign2 = _interopRequireDefault(_assign);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = _assign2.default || 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;
};
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(26), __esModule: true };
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(27);
module.exports = __webpack_require__(30).Object.assign;
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.3.1 Object.assign(target, source)
var $export = __webpack_require__(28);
$export($export.S + $export.F, 'Object', {assign: __webpack_require__(43)});
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(29)
, core = __webpack_require__(30)
, ctx = __webpack_require__(31)
, hide = __webpack_require__(33)
, PROTOTYPE = 'prototype';
var $export = function(type, name, source){
var IS_FORCED = type & $export.F
, IS_GLOBAL = type & $export.G
, IS_STATIC = type & $export.S
, IS_PROTO = type & $export.P
, IS_BIND = type & $export.B
, IS_WRAP = type & $export.W
, exports = IS_GLOBAL ? core : core[name] || (core[name] = {})
, expProto = exports[PROTOTYPE]
, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]
, key, own, out;
if(IS_GLOBAL)source = name;
for(key in source){
// contains in native
own = !IS_FORCED && target && target[key] !== undefined;
if(own && key in exports)continue;
// export native or passed
out = own ? target[key] : source[key];
// prevent global pollution for namespaces
exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
// bind timers to global for call from export context
: IS_BIND && own ? ctx(out, global)
// wrap global constructors for prevent change them in library
: IS_WRAP && target[key] == out ? (function(C){
var F = function(a, b, c){
if(this instanceof C){
switch(arguments.length){
case 0: return new C;
case 1: return new C(a);
case 2: return new C(a, b);
} return new C(a, b, c);
} return C.apply(this, arguments);
};
F[PROTOTYPE] = C[PROTOTYPE];
return F;
// make static versions for prototype methods
})(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
// export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
if(IS_PROTO){
(exports.virtual || (exports.virtual = {}))[key] = out;
// export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
if(type & $export.R && expProto && !expProto[key])hide(expProto, key, out);
}
}
};
// type bitmap
$export.F = 1; // forced
$export.G = 2; // global
$export.S = 4; // static
$export.P = 8; // proto
$export.B = 16; // bind
$export.W = 32; // wrap
$export.U = 64; // safe
$export.R = 128; // real proto method for `library`
module.exports = $export;
/***/ },
/* 29 */
/***/ function(module, exports) {
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
/***/ },
/* 30 */
/***/ function(module, exports) {
var core = module.exports = {version: '2.4.0'};
if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
// optional / simple context binding
var aFunction = __webpack_require__(32);
module.exports = function(fn, that, length){
aFunction(fn);
if(that === undefined)return fn;
switch(length){
case 1: return function(a){
return fn.call(that, a);
};
case 2: return function(a, b){
return fn.call(that, a, b);
};
case 3: return function(a, b, c){
return fn.call(that, a, b, c);
};
}
return function(/* ...args */){
return fn.apply(that, arguments);
};
};
/***/ },
/* 32 */
/***/ function(module, exports) {
module.exports = function(it){
if(typeof it != 'function')throw TypeError(it + ' is not a function!');
return it;
};
/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {
var dP = __webpack_require__(34)
, createDesc = __webpack_require__(42);
module.exports = __webpack_require__(38) ? function(object, key, value){
return dP.f(object, key, createDesc(1, value));
} : function(object, key, value){
object[key] = value;
return object;
};
/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {
var anObject = __webpack_require__(35)
, IE8_DOM_DEFINE = __webpack_require__(37)
, toPrimitive = __webpack_require__(41)
, dP = Object.defineProperty;
exports.f = __webpack_require__(38) ? Object.defineProperty : function defineProperty(O, P, Attributes){
anObject(O);
P = toPrimitive(P, true);
anObject(Attributes);
if(IE8_DOM_DEFINE)try {
return dP(O, P, Attributes);
} catch(e){ /* empty */ }
if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
if('value' in Attributes)O[P] = Attributes.value;
return O;
};
/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(36);
module.exports = function(it){
if(!isObject(it))throw TypeError(it + ' is not an object!');
return it;
};
/***/ },
/* 36 */
/***/ function(module, exports) {
module.exports = function(it){
return typeof it === 'object' ? it !== null : typeof it === 'function';
};
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
module.exports = !__webpack_require__(38) && !__webpack_require__(39)(function(){
return Object.defineProperty(__webpack_require__(40)('div'), 'a', {get: function(){ return 7; }}).a != 7;
});
/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {
// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(39)(function(){
return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
});
/***/ },
/* 39 */
/***/ function(module, exports) {
module.exports = function(exec){
try {
return !!exec();
} catch(e){
return true;
}
};
/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {
var isObject = __webpack_require__(36)
, document = __webpack_require__(29).document
// in old IE typeof document.createElement is 'object'
, is = isObject(document) && isObject(document.createElement);
module.exports = function(it){
return is ? document.createElement(it) : {};
};
/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.1 ToPrimitive(input [, PreferredType])
var isObject = __webpack_require__(36);
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
module.exports = function(it, S){
if(!isObject(it))return it;
var fn, val;
if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
throw TypeError("Can't convert object to primitive value");
};
/***/ },
/* 42 */
/***/ function(module, exports) {
module.exports = function(bitmap, value){
return {
enumerable : !(bitmap & 1),
configurable: !(bitmap & 2),
writable : !(bitmap & 4),
value : value
};
};
/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
// 19.1.2.1 Object.assign(target, source, ...)
var getKeys = __webpack_require__(44)
, gOPS = __webpack_require__(59)
, pIE = __webpack_require__(60)
, toObject = __webpack_require__(61)
, IObject = __webpack_require__(48)
, $assign = Object.assign;
// should work with symbols and should have deterministic property order (V8 bug)
module.exports = !$assign || __webpack_require__(39)(function(){
var A = {}
, B = {}
, S = Symbol()
, K = 'abcdefghijklmnopqrst';
A[S] = 7;
K.split('').forEach(function(k){ B[k] = k; });
return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
}) ? function assign(target, source){ // eslint-disable-line no-unused-vars
var T = toObject(target)
, aLen = arguments.length
, index = 1
, getSymbols = gOPS.f
, isEnum = pIE.f;
while(aLen > index){
var S = IObject(arguments[index++])
, keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
, length = keys.length
, j = 0
, key;
while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
} return T;
} : $assign;
/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.14 / 15.2.3.14 Object.keys(O)
var $keys = __webpack_require__(45)
, enumBugKeys = __webpack_require__(58);
module.exports = Object.keys || function keys(O){
return $keys(O, enumBugKeys);
};
/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {
var has = __webpack_require__(46)
, toIObject = __webpack_require__(47)
, arrayIndexOf = __webpack_require__(51)(false)
, IE_PROTO = __webpack_require__(55)('IE_PROTO');
module.exports = function(object, names){
var O = toIObject(object)
, i = 0
, result = []
, key;
for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
// Don't enum bug & hidden keys
while(names.length > i)if(has(O, key = names[i++])){
~arrayIndexOf(result, key) || result.push(key);
}
return result;
};
/***/ },
/* 46 */
/***/ function(module, exports) {
var hasOwnProperty = {}.hasOwnProperty;
module.exports = function(it, key){
return hasOwnProperty.call(it, key);
};
/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {
// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(48)
, defined = __webpack_require__(50);
module.exports = function(it){
return IObject(defined(it));
};
/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {
// fallback for non-array-like ES3 and non-enumerable old V8 strings
var cof = __webpack_require__(49);
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
return cof(it) == 'String' ? it.split('') : Object(it);
};
/***/ },
/* 49 */
/***/ function(module, exports) {
var toString = {}.toString;
module.exports = function(it){
return toString.call(it).slice(8, -1);
};
/***/ },
/* 50 */
/***/ function(module, exports) {
// 7.2.1 RequireObjectCoercible(argument)
module.exports = function(it){
if(it == undefined)throw TypeError("Can't call method on " + it);
return it;
};
/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {
// false -> Array#indexOf
// true -> Array#includes
var toIObject = __webpack_require__(47)
, toLength = __webpack_require__(52)
, toIndex = __webpack_require__(54);
module.exports = function(IS_INCLUDES){
return function($this, el, fromIndex){
var O = toIObject($this)
, length = toLength(O.length)
, index = toIndex(fromIndex, length)
, value;
// Array#includes uses SameValueZero equality algorithm
if(IS_INCLUDES && el != el)while(length > index){
value = O[index++];
if(value != value)return true;
// Array#toIndex ignores holes, Array#includes - not
} else for(;length > index; index++)if(IS_INCLUDES || index in O){
if(O[index] === el)return IS_INCLUDES || index || 0;
} return !IS_INCLUDES && -1;
};
};
/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.15 ToLength
var toInteger = __webpack_require__(53)
, min = Math.min;
module.exports = function(it){
return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
};
/***/ },
/* 53 */
/***/ function(module, exports) {
// 7.1.4 ToInteger
var ceil = Math.ceil
, floor = Math.floor;
module.exports = function(it){
return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
};
/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {
var toInteger = __webpack_require__(53)
, max = Math.max
, min = Math.min;
module.exports = function(index, length){
index = toInteger(index);
return index < 0 ? max(index + length, 0) : min(index, length);
};
/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {
var shared = __webpack_require__(56)('keys')
, uid = __webpack_require__(57);
module.exports = function(key){
return shared[key] || (shared[key] = uid(key));
};
/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {
var global = __webpack_require__(29)
, SHARED = '__core-js_shared__'
, store = global[SHARED] || (global[SHARED] = {});
module.exports = function(key){
return store[key] || (store[key] = {});
};
/***/ },
/* 57 */
/***/ function(module, exports) {
var id = 0
, px = Math.random();
module.exports = function(key){
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
};
/***/ },
/* 58 */
/***/ function(module, exports) {
// IE 8- don't enum bug keys
module.exports = (
'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
).split(',');
/***/ },
/* 59 */
/***/ function(module, exports) {
exports.f = Object.getOwnPropertySymbols;
/***/ },
/* 60 */
/***/ function(module, exports) {
exports.f = {}.propertyIsEnumerable;
/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {
// 7.1.13 ToObject(argument)
var defined = __webpack_require__(50);
module.exports = function(it){
return Object(defined(it));
};
/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(63), __esModule: true };
/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(64);
module.exports = __webpack_require__(30).Object.keys;
/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {
// 19.1.2.14 Object.keys(O)
var toObject = __webpack_require__(61)
, $keys = __webpack_require__(44);
__webpack_require__(65)('keys', function(){
return function keys(it){
return $keys(toObject(it));
};
});
/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {
// most Object methods by ES6 should accept primitives
var $export = __webpack_require__(28)
, core = __webpack_require__(30)
, fails = __webpack_require__(39);
module.exports = function(KEY, exec){
var fn = (core.Object || {})[KEY] || Object[KEY]
, exp = {};
exp[KEY] = exec(fn);
$export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp);
};
/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(67);
/***/ },
/* 67 */
/***/ function(module, exports) {
"use strict";
exports.__esModule = true;
exports.default = function (obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
};
/***/ },
/* 68 */
/***/ function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_68__;
/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _iconIcon = __webpack_require__(70);
var _iconIcon2 = _interopRequireDefault(_iconIcon);
var _spinnerSpinner = __webpack_require__(71);
var _spinnerSpinner2 = _interopRequireDefault(_spinnerSpinner);
var Overlay = _react2['default'].createClass({
displayName: 'Overlay',
propTypes: {
error: _react2['default'].PropTypes.bool,
togglePlay: _react2['default'].PropTypes.func,
paused: _react2['default'].PropTypes.bool,
copyKeys: _react2['default'].PropTypes.object,
loading: _react2['default'].PropTypes.bool
},
renderContent: function renderContent() {
var content;
if (this.props.error) {
content = _react2['default'].createElement(
'div',
{ className: 'video-overlay__error' },
_react2['default'].createElement(
'p',
{ className: 'video-overlay__error-text' },
this.props.copyKeys.sourceError
)
);
} else if (this.props.loading) {
content = _react2['default'].createElement(
'div',
{ className: 'video-overlay__loader' },
_react2['default'].createElement(_spinnerSpinner2['default'], null)
);
} else {
content = _react2['default'].createElement(
'div',
{ className: 'video-overlay__play', onClick: this.props.togglePlay },
this.props.paused ? _react2['default'].createElement(_iconIcon2['default'], { name: 'play-1' }) : ''
);
}
return content;
},
render: function render() {
return _react2['default'].createElement(
'div',
{ className: 'video-overlay' },
this.renderContent()
);
}
});
exports['default'] = Overlay;
module.exports = exports['default'];
/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {
/*eslint-disable */
/*
* Generated by the 'fontello-react' Grunt task.
*/
'use strict';
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var Icon = _react2['default'].createClass({
displayName: 'Icon',
propTypes: {
name: _react2['default'].PropTypes.oneOf(['play-1', 'volume-off', 'volume-down', 'volume-up', 'resize-full', 'resize-small', 'pause-1'])
},
/**
* Default the icon to the first one just to show something
* @return {Object} The default props
*/
getDefaultProps: function getDefaultProps() {
return {
name: 'play-1'
};
},
render: function render() {
return _react2['default'].createElement('span', { className: 'video-icon video-icon--' + this.props.name });
}
});
exports['default'] = Icon;
module.exports = exports['default'];
/***/ },
/* 71 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
var _interopRequireDefault = __webpack_require__(66)["default"];
Object.defineProperty(exports, "__esModule", {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var Spinner = _react2["default"].createClass({
displayName: "Spinner",
render: function render() {
return _react2["default"].createElement(
"div",
{ className: "video-spinner" },
_react2["default"].createElement("div", { className: "video-spinner__rect1" }),
_react2["default"].createElement("div", { className: "video-spinner__rect2" }),
_react2["default"].createElement("div", { className: "video-spinner__rect3" }),
_react2["default"].createElement("div", { className: "video-spinner__rect4" }),
_react2["default"].createElement("div", { className: "video-spinner__rect5" })
);
}
});
exports["default"] = Spinner;
module.exports = exports["default"];
/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _extends = __webpack_require__(24)['default'];
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _playPlay = __webpack_require__(73);
var _playPlay2 = _interopRequireDefault(_playPlay);
var _seekSeek = __webpack_require__(74);
var _seekSeek2 = _interopRequireDefault(_seekSeek);
var _muteMute = __webpack_require__(81);
var _muteMute2 = _interopRequireDefault(_muteMute);
var _timeTime = __webpack_require__(82);
var _timeTime2 = _interopRequireDefault(_timeTime);
var _fullscreenFullscreen = __webpack_require__(83);
var _fullscreenFullscreen2 = _interopRequireDefault(_fullscreenFullscreen);
var Controls = _react2['default'].createClass({
displayName: 'Controls',
propTypes: {
error: _react2['default'].PropTypes.bool,
children: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.arrayOf(_react2['default'].PropTypes.node), _react2['default'].PropTypes.node])
},
getDefaultProps: function getDefaultProps() {
return {
children: [_react2['default'].createElement(_playPlay2['default'], null), _react2['default'].createElement(_seekSeek2['default'], null), _react2['default'].createElement(_timeTime2['default'], null), _react2['default'].createElement(_muteMute2['default'], null), _react2['default'].createElement(_fullscreenFullscreen2['default'], null)]
};
},
/**
* Returns children components with props
* from the parent Video component. Needed
* for when custom React components are used.
* @return {Array.<ReactElement>} An array of components.
*/
renderChildren: function renderChildren() {
var _this = this;
return _react2['default'].Children.map(this.props.children, function (child) {
return _react2['default'].cloneElement(child, _extends({}, _this.props));
});
},
render: function render() {
return !this.props.error ? _react2['default'].createElement(
'div',
{ className: 'video-controls video__controls' },
this.renderChildren()
) : null;
}
});
exports['default'] = Controls;
module.exports = exports['default'];
/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _iconIcon = __webpack_require__(70);
var _iconIcon2 = _interopRequireDefault(_iconIcon);
var Play = _react2['default'].createClass({
displayName: 'Play',
propTypes: {
copyKeys: _react2['default'].PropTypes.object,
togglePlay: _react2['default'].PropTypes.func,
paused: _react2['default'].PropTypes.bool
},
/**
* As controls receive all props for extensibility, we do a quick
* check and make sure only the props we care about have changed.
* @param {object} nextProps The next props from parent
* @return {boolean} Whether we re-render or not
*/
shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
return this.props.paused !== nextProps.paused || this.props.togglePlay !== nextProps.togglePlay;
},
render: function render() {
return _react2['default'].createElement(
'button',
{
className: 'video-play video__control',
onClick: this.props.togglePlay,
'aria-label': this.props.paused ? this.props.copyKeys.play : this.props.copyKeys.pause },
this.props.paused ? _react2['default'].createElement(_iconIcon2['default'], { name: 'play-1' }) : _react2['default'].createElement(_iconIcon2['default'], { name: 'pause-1' })
);
}
});
exports['default'] = Play;
module.exports = exports['default'];
/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _progressbarProgressBar = __webpack_require__(75);
var _progressbarProgressBar2 = _interopRequireDefault(_progressbarProgressBar);
var Seek = _react2['default'].createClass({
displayName: 'Seek',
propTypes: {
copyKeys: _react2['default'].PropTypes.object,
seek: _react2['default'].PropTypes.func,
percentageBuffered: _react2['default'].PropTypes.number,
percentagePlayed: _react2['default'].PropTypes.number,
duration: _react2['default'].PropTypes.number
},
getInitialState: function getInitialState() {
return {
// When the child range input becomes focused,
// we need to set this custom seek bar to look
// 'focused' with the correct styles. Need to
// do this via a class.
focused: false
};
},
/**
* As controls receive all props for extensibility, we do a quick
* check and make sure only the props we care about have changed.
* @param {object} nextProps The next props from parent
* @return {boolean} Whether we re-render or not
*/
shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
return this.props.seek !== nextProps.seek || this.props.percentageBuffered !== nextProps.percentageBuffered || this.props.percentagePlayed !== nextProps.percentagePlayed || this.props.duration !== nextProps.duration;
},
/**
* Calculates the seek time based on change of input.
* @param {object} e Event object
* @return {undefined}
*/
seek: function seek(e) {
this.props.seek(e.target.value * this.props.duration / 100, true);
},
onFocus: function onFocus() {
this.setState({
focused: true
});
},
onBlur: function onBlur() {
this.setState({
focused: false
});
},
render: function render() {
return _react2['default'].createElement(
'div',
{
className: 'video-seek video__control' + (this.state.focused ? ' video__control--focused' : ''),
'aria-label': this.props.copyKeys.seek },
_react2['default'].createElement(
'div',
{ className: 'video-seek__container' },
_react2['default'].createElement('div', { style: {
width: this.props.percentageBuffered + '%'
}, className: 'video-seek__buffer-bar' }),
_react2['default'].createElement(_progressbarProgressBar2['default'], {
onBlur: this.onBlur,
onFocus: this.onFocus,
onChange: this.seek,
progress: this.props.percentagePlayed })
)
);
}
});
exports['default'] = Seek;
module.exports = exports['default'];
/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _defineProperty = __webpack_require__(76)['default'];
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var ProgressBar = _react2['default'].createClass({
displayName: 'ProgressBar',
propTypes: {
orientation: _react2['default'].PropTypes.string,
step: _react2['default'].PropTypes.number,
progress: _react2['default'].PropTypes.number,
onChange: _react2['default'].PropTypes.func,
onFocus: _react2['default'].PropTypes.func,
onBlur: _react2['default'].PropTypes.func
},
getDefaultProps: function getDefaultProps() {
return {
orientation: 'horizontal',
step: 0.1,
progress: 0,
onChange: this.onChange,
onFocus: this.onFocus,
onBlur: this.onBlur
};
},
componentDidMount: function componentDidMount() {
// 'orient' is not supported by React but
// is required for Firefox. Setting manually.
// https://github.com/facebook/react/issues/2453
this.refs.input.setAttribute('orient', this.props.orientation);
},
onChange: function onChange() {
// Placeholder
},
onFocus: function onFocus() {
// Placeholder
},
onBlur: function onBlur() {
// Placeholder
},
render: function render() {
return _react2['default'].createElement(
'div',
{ className: 'video-progress-bar ' + (this.props.orientation === 'horizontal' ? 'video-progress-bar--horizontal' : 'video-progress-bar--vertical') },
_react2['default'].createElement('div', { className: 'video-progress-bar__fill', style: _defineProperty({}, this.props.orientation === 'horizontal' ? 'width' : 'height', this.props.progress + '%') }),
_react2['default'].createElement('input', { className: 'video-progress-bar__input',
onBlur: this.props.onBlur,
onFocus: this.props.onFocus,
ref: 'input',
onChange: this.props.onChange,
type: 'range',
min: '0',
max: '100',
value: this.props.progress,
step: this.props.step })
);
}
});
exports['default'] = ProgressBar;
module.exports = exports['default'];
/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(77);
/***/ },
/* 77 */
/***/ function(module, exports, __webpack_require__) {
"use strict";
exports.__esModule = true;
var _defineProperty = __webpack_require__(78);
var _defineProperty2 = _interopRequireDefault(_defineProperty);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = function (obj, key, value) {
if (key in obj) {
(0, _defineProperty2.default)(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
};
/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {
module.exports = { "default": __webpack_require__(79), __esModule: true };
/***/ },
/* 79 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(80);
var $Object = __webpack_require__(30).Object;
module.exports = function defineProperty(it, key, desc){
return $Object.defineProperty(it, key, desc);
};
/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {
var $export = __webpack_require__(28);
// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
$export($export.S + $export.F * !__webpack_require__(38), 'Object', {defineProperty: __webpack_require__(34).f});
/***/ },
/* 81 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _iconIcon = __webpack_require__(70);
var _iconIcon2 = _interopRequireDefault(_iconIcon);
var _progressbarProgressBar = __webpack_require__(75);
var _progressbarProgressBar2 = _interopRequireDefault(_progressbarProgressBar);
var Mute = _react2['default'].createClass({
displayName: 'Mute',
propTypes: {
copyKeys: _react2['default'].PropTypes.object,
volume: _react2['default'].PropTypes.number,
unmute: _react2['default'].PropTypes.func,
setVolume: _react2['default'].PropTypes.func,
toggleMute: _react2['default'].PropTypes.func,
muted: _react2['default'].PropTypes.bool
},
/**
* As controls receive all props for extensibility, we do a quick
* check and make sure only the props we care about have changed.
* @param {object} nextProps The next props from parent
* @return {boolean} Whether we re-render or not
*/
shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
return this.props.muted !== nextProps.muted || this.props.toggleMute !== nextProps.toggleMute || this.props.volume !== nextProps.volume || this.props.setVolume !== nextProps.setVolume || this.props.unmute !== nextProps.unmute;
},
/**
* Calculates the seek time based on click position and element offset.
* @param {object} e Event object
* @return {undefined}
*/
changeVolume: function changeVolume(e) {
this.props.setVolume(e.target.value / 100, true);
this.props.unmute();
},
toggleMute: function toggleMute() {
// If we volume has been dragged to 0, assume it is in
// a muted state and then toggle to full volume.
if (this.props.volume <= 0) {
this.props.setVolume(1);
} else {
this.props.toggleMute();
}
},
render: function render() {
return _react2['default'].createElement(
'div',
{ className: 'video-mute video__control' },
_react2['default'].createElement(
'button',
{
className: 'video-mute__inner',
onClick: this.toggleMute,
'aria-label': this.props.muted || this.props.volume <= 0 ? this.props.copyKeys.unmute : this.props.copyKeys.mute },
this.props.muted || this.props.volume <= 0 ? _react2['default'].createElement(_iconIcon2['default'], { name: 'volume-off' }) : _react2['default'].createElement(_iconIcon2['default'], { name: 'volume-up' })
),
_react2['default'].createElement(
'div',
{ className: 'video-mute__volume' },
_react2['default'].createElement(
'div',
{ className: 'video-mute__track' },
_react2['default'].createElement(_progressbarProgressBar2['default'], {
orientation: 'vertical',
onChange: this.changeVolume,
progress: this.props.muted ? 0 : this.props.volume * 100
})
)
)
);
}
});
exports['default'] = Mute;
module.exports = exports['default'];
/***/ },
/* 82 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _iconIcon = __webpack_require__(70);
var _iconIcon2 = _interopRequireDefault(_iconIcon);
var Time = _react2['default'].createClass({
displayName: 'Time',
propTypes: {
currentTime: _react2['default'].PropTypes.number,
duration: _react2['default'].PropTypes.number
},
/**
* As controls receive all props for extensibility, we do a quick
* check and make sure only the props we care about have changed.
* @param {object} nextProps The next props from parent
* @return {boolean} Whether we re-render or not
*/
shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
return this.props.currentTime !== nextProps.currentTime || this.props.duration !== nextProps.duration;
},
/**
* Formats time into a friendlier format
* @param {number} seconds Time in seconds
* @return {string} Timestamp in the format of HH:MM:SS
*/
formatTime: function formatTime(seconds) {
var date = new Date(Date.UTC(1970, 1, 1, 0, 0, 0, 0));
seconds = isNaN(seconds) ? 0 : Math.floor(seconds);
date.setSeconds(seconds);
return date.toISOString().substr(11, 8);
},
render: function render() {
return _react2['default'].createElement(
'div',
{ className: 'video-time video__control' },
_react2['default'].createElement(
'span',
{ className: 'video-time__current' },
this.formatTime(this.props.currentTime)
),
'/',
_react2['default'].createElement(
'span',
{ className: 'video-time__duration' },
this.formatTime(this.props.duration)
)
);
}
});
exports['default'] = Time;
module.exports = exports['default'];
/***/ },
/* 83 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _iconIcon = __webpack_require__(70);
var _iconIcon2 = _interopRequireDefault(_iconIcon);
var Fullscreen = _react2['default'].createClass({
displayName: 'Fullscreen',
propTypes: {
copyKeys: _react2['default'].PropTypes.object,
fullscreen: _react2['default'].PropTypes.func
},
/**
* As controls receive all props for extensibility, we do a quick
* check and make sure only the props we care about have changed.
* @param {object} nextProps The next props from parent
* @return {boolean} Whether we re-render or not
*/
shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
return this.props.fullscreen !== nextProps.fullscreen;
},
render: function render() {
return _react2['default'].createElement(
'button',
{
onClick: this.props.fullscreen,
className: 'video-fullscreen video__control',
'aria-label': this.props.copyKeys.fullscreen },
_react2['default'].createElement(_iconIcon2['default'], { name: 'resize-full' })
);
}
});
exports['default'] = Fullscreen;
module.exports = exports['default'];
/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var _Object$keys = __webpack_require__(62)['default'];
var _interopRequireDefault = __webpack_require__(66)['default'];
Object.defineProperty(exports, '__esModule', {
value: true
});
var _react = __webpack_require__(68);
var _react2 = _interopRequireDefault(_react);
var _iconIcon = __webpack_require__(70);
var _iconIcon2 = _interopRequireDefault(_iconIcon);
var Subtitles = _react2['default'].createClass({
displayName: 'Subtitles',
propTypes: {
currentLabel: _react2['default'].PropTypes.string,
showMenu: _react2['default'].PropTypes.bool,
textTracks: _react2['default'].PropTypes.object,
setTextTrack: _react2['default'].PropTypes.func,
textTrackSelected: _react2['default'].PropTypes.any
},
showSubtitles: function showSubtitles(key) {
this.props.setTextTrack(key);
},
/**
* As controls receive all props for extensibility, we do a quick
* check and make sure only the props we care about have changed.
* @param {object} nextProps The next props from parent
* @return {boolean} Whether we re-render or not
*/
shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
return this.props.textTrackSelected !== nextProps.textTrackSelected || this.props.textTracks !== nextProps.textTracks;
},
render: function render() {
var _this = this;
if (_Object$keys(this.props.textTracks).length) {
return _react2['default'].createElement(
'div',
{ className: 'video-subtitles video__control' },
_react2['default'].createElement(
'div',
{ className: 'video-menu-button-popup video-control', title: 'Subtitles' },
_react2['default'].createElement(
'div',
{ className: 'video-menu' },
_react2['default'].createElement(
'ul',
{ className: 'video-menu-content' },
_react2['default'].createElement(
'li',
{ className: 'video-menu-item ' + (!this.props.textTrackSelected ? 'video-selected' : ''),
onClick: function () {
_this.showSubtitles();
} },
'Subtitles off'
),
_Object$keys(this.props.textTracks).map(function (key) {
return _react2['default'].createElement(
'li',
{ key: 'text_' + key,
className: 'video-menu-item ' + (_this.props.textTrackSelected == key ? 'video-selected' : ''),
onClick: function () {
_this.showSubtitles(key);
} },
_this.props.textTracks[key].label
);
})
)
),
_react2['default'].createElement(
'span',
{ className: 'video-control-text' },
'cc'
)
)
);
} else {
return null;
}
}
});
exports['default'] = Subtitles;
module.exports = exports['default'];
/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {
/**
* lodash 3.0.4 (Custom Build) <https://lodash.com/>
* Build: `lodash modern modularize exports="npm" -o ./`
* Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
* Available under MIT license <https://lodash.com/license>
*/
var debounce = __webpack_require__(86);
/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';
/**
* Creates a throttled function that only invokes `func` at most once per
* every `wait` milliseconds. The throttled function comes with a `cancel`
* method to cancel delayed invocations. Provide an options object to indicate
* that `func` should be invoked on the leading and/or trailing edge of the
* `wait` timeout. Subsequent calls to the throttled function return the
* result of the last `func` call.
*
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
* on the trailing edge of the timeout only if the the throttled function is
* invoked more than once during the `wait` timeout.
*
* See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
* for details over the differences between `_.throttle` and `_.debounce`.
*
* @static
* @memberOf _
* @category Function
* @param {Function} func The function to throttle.
* @param {number} [wait=0] The number of milliseconds to throttle invocations to.
* @param {Object} [options] The options object.
* @param {boolean} [options.leading=true] Specify invoking on the leading
* edge of the timeout.
* @param {boolean} [options.trailing=true] Specify invoking on the trailing
* edge of the timeout.
* @returns {Function} Returns the new throttled function.
* @example
*
* // avoid excessively updating the position while scrolling
* jQuery(window).on('scroll', _.throttle(updatePosition, 100));
*
* // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes
* jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {
* 'trailing': false
* }));
*
* // cancel a trailing throttled call
* jQuery(window).on('popstate', throttled.cancel);
*/
function throttle(func, wait, options) {
var leading = true,
trailing = true;
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
if (options === false) {
leading = false;
} else if (isObject(options)) {
leading = 'leading' in options ? !!options.leading : leading;
trailing = 'trailing' in options ? !!options.trailing : trailing;
}
return debounce(func, wait, { 'leading': leading, 'maxWait': +wait, 'trailing': trailing });
}
/**
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(1);
* // => false
*/
function isObject(value) {
// Avoid a V8 JIT bug in Chrome 19-20.
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
var type = typeof value;
return !!value && (type == 'object' || type == 'function');
}
module.exports = throttle;
/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {
/**
* lodash 3.1.1 (Custom Build) <https://lodash.com/>
* Build: `lodash modern modularize exports="npm" -o ./`
* Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
* Available under MIT license <https://lodash.com/license>
*/
var getNative = __webpack_require__(87);
/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';
/* Native method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max,
nativeNow = getNative(Date, 'now');
/**
* Gets the number of milliseconds that have elapsed since the Unix epoch
* (1 January 1970 00:00:00 UTC).
*
* @static
* @memberOf _
* @category Date
* @example
*
* _.defer(function(stamp) {
* console.log(_.now() - stamp);
* }, _.now());
* // => logs the number of milliseconds it took for the deferred function to be invoked
*/
var now = nativeNow || function() {
return new Date().getTime();
};
/**
* Creates a debounced function that delays invoking `func` until after `wait`
* milliseconds have elapsed since the last time the debounced function was
* invoked. The debounced function comes with a `cancel` method to cancel
* delayed invocations. Provide an options object to indicate that `func`
* should be invoked on the leading and/or trailing edge of the `wait` timeout.
* Subsequent calls to the debounced function return the result of the last
* `func` invocation.
*
* **Note:** If `leading` and `trailing` options are `true`, `func` is invoked
* on the trailing edge of the timeout only if the the debounced function is
* invoked more than once during the `wait` timeout.
*
* See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)
* for details over the differences between `_.debounce` and `_.throttle`.
*
* @static
* @memberOf _
* @category Function
* @param {Function} func The function to debounce.
* @param {number} [wait=0] The number of milliseconds to delay.
* @param {Object} [options] The options object.
* @param {boolean} [options.leading=false] Specify invoking on the leading
* edge of the timeout.
* @param {number} [options.maxWait] The maximum time `func` is allowed to be
* delayed before it is invoked.
* @param {boolean} [options.trailing=true] Specify invoking on the trailing
* edge of the timeout.
* @returns {Function} Returns the new debounced function.
* @example
*
* // avoid costly calculations while the window size is in flux
* jQuery(window).on('resize', _.debounce(calculateLayout, 150));
*
* // invoke `sendMail` when the click event is fired, debouncing subsequent calls
* jQuery('#postbox').on('click', _.debounce(sendMail, 300, {
* 'leading': true,
* 'trailing': false
* }));
*
* // ensure `batchLog` is invoked once after 1 second of debounced calls
* var source = new EventSource('/stream');
* jQuery(source).on('message', _.debounce(batchLog, 250, {
* 'maxWait': 1000
* }));
*
* // cancel a debounced call
* var todoChanges = _.debounce(batchLog, 1000);
* Object.observe(models.todo, todoChanges);
*
* Object.observe(models, function(changes) {
* if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {
* todoChanges.cancel();
* }
* }, ['delete']);
*
* // ...at some point `models.todo` is changed
* models.todo.completed = true;
*
* // ...before 1 second has passed `models.todo` is deleted
* // which cancels the debounced `todoChanges` call
* delete models.todo;
*/
function debounce(func, wait, options) {
var args,
maxTimeoutId,
result,
stamp,
thisArg,
timeoutId,
trailingCall,
lastCalled = 0,
maxWait = false,
trailing = true;
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
wait = wait < 0 ? 0 : (+wait || 0);
if (options === true) {
var leading = true;
trailing = false;
} else if (isObject(options)) {
leading = !!options.leading;
maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);
trailing = 'trailing' in options ? !!options.trailing : trailing;
}
function cancel() {
if (timeoutId) {
clearTimeout(timeoutId);
}
if (maxTimeoutId) {
clearTimeout(maxTimeoutId);
}
lastCalled = 0;
maxTimeoutId = timeoutId = trailingCall = undefined;
}
function complete(isCalled, id) {
if (id) {
clearTimeout(id);
}
maxTimeoutId = timeoutId = trailingCall = undefined;
if (isCalled) {
lastCalled = now();
result = func.apply(thisArg, args);
if (!timeoutId && !maxTimeoutId) {
args = thisArg = undefined;
}
}
}
function delayed() {
var remaining = wait - (now() - stamp);
if (remaining <= 0 || remaining > wait) {
complete(trailingCall, maxTimeoutId);
} else {
timeoutId = setTimeout(delayed, remaining);
}
}
function maxDelayed() {
complete(trailing, timeoutId);
}
function debounced() {
args = arguments;
stamp = now();
thisArg = this;
trailingCall = trailing && (timeoutId || !leading);
if (maxWait === false) {
var leadingCall = leading && !timeoutId;
} else {
if (!maxTimeoutId && !leading) {
lastCalled = stamp;
}
var remaining = maxWait - (stamp - lastCalled),
isCalled = remaining <= 0 || remaining > maxWait;
if (isCalled) {
if (maxTimeoutId) {
maxTimeoutId = clearTimeout(maxTimeoutId);
}
lastCalled = stamp;
result = func.apply(thisArg, args);
}
else if (!maxTimeoutId) {
maxTimeoutId = setTimeout(maxDelayed, remaining);
}
}
if (isCalled && timeoutId) {
timeoutId = clearTimeout(timeoutId);
}
else if (!timeoutId && wait !== maxWait) {
timeoutId = setTimeout(delayed, wait);
}
if (leadingCall) {
isCalled = true;
result = func.apply(thisArg, args);
}
if (isCalled && !timeoutId && !maxTimeoutId) {
args = thisArg = undefined;
}
return result;
}
debounced.cancel = cancel;
return debounced;
}
/**
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(1);
* // => false
*/
function isObject(value) {
// Avoid a V8 JIT bug in Chrome 19-20.
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
var type = typeof value;
return !!value && (type == 'object' || type == 'function');
}
module.exports = debounce;
/***/ },
/* 87 */
/***/ function(module, exports) {
/**
* lodash 3.9.1 (Custom Build) <https://lodash.com/>
* Build: `lodash modern modularize exports="npm" -o ./`
* Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
* Available under MIT license <https://lodash.com/license>
*/
/** `Object#toString` result references. */
var funcTag = '[object Function]';
/** Used to detect host constructors (Safari > 5). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;
/**
* Checks if `value` is object-like.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
*/
function isObjectLike(value) {
return !!value && typeof value == 'object';
}
/** Used for native method references. */
var objectProto = Object.prototype;
/** Used to resolve the decompiled source of functions. */
var fnToString = Function.prototype.toString;
/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;
/**
* Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
* of values.
*/
var objToString = objectProto.toString;
/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);
/**
* Gets the native function at `key` of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the method to get.
* @returns {*} Returns the function if it's native, else `undefined`.
*/
function getNative(object, key) {
var value = object == null ? undefined : object[key];
return isNative(value) ? value : undefined;
}
/**
* Checks if `value` is classified as a `Function` object.
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
* @example
*
* _.isFunction(_);
* // => true
*
* _.isFunction(/abc/);
* // => false
*/
function isFunction(value) {
// The use of `Object#toString` avoids issues with the `typeof` operator
// in older versions of Chrome and Safari which return 'function' for regexes
// and Safari 8 equivalents which return 'object' for typed array constructors.
return isObject(value) && objToString.call(value) == funcTag;
}
/**
* Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
* (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(1);
* // => false
*/
function isObject(value) {
// Avoid a V8 JIT bug in Chrome 19-20.
// See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
var type = typeof value;
return !!value && (type == 'object' || type == 'function');
}
/**
* Checks if `value` is a native function.
*
* @static
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a native function, else `false`.
* @example
*
* _.isNative(Array.prototype.push);
* // => true
*
* _.isNative(_);
* // => false
*/
function isNative(value) {
if (value == null) {
return false;
}
if (isFunction(value)) {
return reIsNative.test(fnToString.call(value));
}
return isObjectLike(value) && reIsHostCtor.test(value);
}
module.exports = getNative;
/***/ },
/* 88 */
/***/ function(module, exports) {
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
var copy = {
sourceError: 'Video cannot be played in this browser.',
play: 'Play video',
pause: 'Pause video',
mute: 'Mute video',
unmute: 'Unmute video',
fullscreen: 'View video fullscreen',
seek: 'Seek video'
};
exports['default'] = copy;
module.exports = exports['default'];
/***/ }
/******/ ])
});
; |
module.exports = {
test: val => val && typeof val === 'object',
print: val => JSON.stringify(val, null, 2),
};
|
const gear = require('../../gearbox.js');
const fs = require('fs');
const request = require('request');
const download = async function(uri, filename, callback){
request.head(uri, async function(err, res, body){
console.log('content-type:', res.headers['content-type']);
console.log('content-length:', res.headers['content-length']);
request(uri).pipe(fs.createWriteStream(filename)).on('close', callback);
});
};
const cmd = 'ping';
const init = async function (message) {
console.log('poo')
if (message.channel.id!='364811796776878091')return;
try {
let nwurl = await gear.getImg(message, true);
let ts = "lewd-" + Date.now();
await download(nwurl, '/root/v7/resources/imgres/lewd/' + message.author.id + "-" + ts + '.png', function (x) {
message.reply(gear.emoji('yep') + "Lewdle Uploaded Successfully!")
});
} catch (e) {
console.error(e)
}
};
module.exports = {
cool: 10,
pub: false,
cmd: cmd,
perms: 3,
init: init,
cat: 'infra'
};
|
import Icon from '../components/Icon.vue'
Icon.register({
'hand-point-left': {
width: 512,
height: 512,
paths: [
{
d: 'M44.8 155.8h149.2c-5.8-8.2-10.6-16.6-14.2-24.9-13.6-31.8 9.9-66.9 44.1-66.9 18.6 0 32.2 10.9 40 29.1 12.1 28.3 78.6 64.3 107.5 77.3 17.9 8 28.5 25.5 28.5 43.8l0 0v171.5c0 11.8-8.6 21.9-20.3 23.7-46.8 7.3-61.8 38.5-123.7 38.3-2.7 0-13.3 0.2-16 0.2-50.7 0-81.6-22.1-72.6-71.3-18.6-9.3-30.7-39.5-16.5-62.3-24.6-21.2-22.6-53.9-6.3-70.9h-99.9c-24.1 0-44.8-20.2-44.8-43.8 0-23.3 21.3-43.8 44.8-43.8zM440 176h48c13.3 0 24 10.7 24 24v192c0 13.3-10.7 24-24 24h-48c-13.3 0-24-10.7-24-24v-192c0-13.3 10.7-24 24-24zM464 388c11 0 20-9 20-20s-9-20-20-20-20 9-20 20 9 20 20 20z'
}
]
}
})
|
Template.registerHelper('pages', function(kw) {
var options = (kw && kw.hash) || {};
return scorpius.pages.collection.find(options);
});
ReactiveTemplates.helpers('pages.index', {
tabularTable: function() {
return scorpius.pages.tabular;
},
});
/**
* Create Route
*/
ReactiveTemplates.onRendered('pages.create', function() {
if (_.keys(scorpius.pages.templates).length == 1) {
Session.set('adminPagesCreate_choosenTemplate', _.keys(scorpius.pages.templates)[0]);
} else {
Session.set('adminPagesCreate_choosenTemplate', null);
}
});
ReactiveTemplates.helpers('pages.create', {
choosenTemplate: function() {
var name = Session.get('adminPagesCreate_choosenTemplate');
return name && scorpius.pages.templates[name];
},
templates: function() {
return _.values(scorpius.pages.templates);
},
});
ReactiveTemplates.events('pages.create', {
'click .template-choose': function() {
Session.set('adminPagesCreate_choosenTemplate', this.template);
},
'click .cancel-btn': function() {
if (_.keys(scorpius.pages.templates).length == 1) {
Meteor.defer(function() {
RouterLayer.go('pages.index');
});
} else {
Session.set('adminPagesCreate_choosenTemplate', null);
}
},
'click .submit-btn': function() {
$('#scorpiusPagesCreateForm').submit();
},
});
AutoForm.hooks({
scorpiusPagesCreateForm: {
before: {
insert: function(doc) {
var self = this;
var name = Session.get('adminPagesCreate_choosenTemplate');
if (!name) {
self.result(false);
} else {
doc = scorpius.pages.templates[name].schema.clean(doc, {
extendAutoValueContext: {
isInsert: true,
userId: Meteor.userId(),
},
});
Meteor.call('scorpius_pageWithUrl', doc.url, function(error, result) {
if (!result) {
self.result(doc);
} else {
scorpius.pages.templates[name].schema.namedContext('scorpiusPagesCreateForm').addInvalidKeys([{name: 'url', type: 'notUnique'}]);
self.result(false);
}
});
}
},
},
onSuccess: function() {
RouterLayer.go('pages.index');
},
},
});
/**
* Update route
*/
AutoForm.hooks({
scorpiusPagesUpdateForm: {
before: {
update: function(doc) {
var self = this;
var updatingPage = doc.$set;
var name = updatingPage.template;
if (!name) {
self.result(false);
} else {
doc = scorpius.pages.templates[name].schema.clean(doc, {
extendAutoValueContext: {
isUpdate: true,
userId: Meteor.userId(),
},
});
Meteor.call('scorpius_pageWithUrl', updatingPage.url, function(error, result) {
if (result && result._id != self.docId) {
scorpius.pages.templates[name].schema.namedContext('scorpiusPagesUpdateForm').addInvalidKeys([{name: 'url', type: 'notUnique'}]);
self.result(false);
} else {
self.result(doc);
}
});
}
},
},
onSuccess: function() {
RouterLayer.go('pages.index');
},
},
});
ReactiveTemplates.onCreated('pages.update', function() {
var self = this;
self.autorun(function() {
self.subscribe('pageById', RouterLayer.getParam('_id'));
});
});
ReactiveTemplates.helpers('pages.update', {
getSchema: function() {
var item = scorpius.pages.collection.findOne(RouterLayer.getParam('_id'));
return item && scorpius.pages.templates[item.template] && scorpius.pages.templates[item.template].schema;
},
item: function() {
return scorpius.pages.collection.findOne(RouterLayer.getParam('_id'));
},
});
ReactiveTemplates.events('pages.update', {
'click .save-btn': function() {
$('#scorpiusPagesUpdateForm').submit();
},
});
/**
* Delete route
*/
ReactiveTemplates.onCreated('pages.delete', function() {
var self = this;
self.autorun(function() {
self.subscribe('pageById', RouterLayer.getParam('_id'));
});
});
ReactiveTemplates.helpers('pages.delete', {
onSuccess: function() {
return function(result) {
RouterLayer.go('pages.index');
};
},
item: function() {
return scorpius.pages.collection.findOne(RouterLayer.getParam('_id'));
},
});
ReactiveTemplates.events('pages.delete', {
'click .confirm-delete': function() {
scorpius.pages.collection.remove(this._id, function() {
RouterLayer.go('pages.index');
});
},
});
/**
* Reactive Templates
*/
ReactiveTemplates.request('pages.loading', 'scorpiusPages_defaultLoading');
ReactiveTemplates.request('pages.notFound', 'scorpiusPages_defaultNotFound');
/**
* Pages main template
*/
Template.scorpiusPages_mainTemplate.onCreated(function() {
var self = this;
self.autorun(function() {
self.subscribe('page', RouterLayer.getParam('url'));
});
});
Template.scorpiusPages_mainTemplate.helpers({
page: function() {
return scorpius.pages.collection.findOne({ url: RouterLayer.getParam('url') });
},
layout: function() {
var page = scorpius.pages.collection.findOne({ url: RouterLayer.getParam('url') });
var template = scorpius.pages.templates[page.template];
return template.layout;
},
template: function() {
var page = scorpius.pages.collection.findOne({ url: RouterLayer.getParam('url') });
return page.template;
},
});
|
import Vue from 'vue'
import CAvatar from 'components/c-avatar'
describe('avatar.vue', () => {
let el
let vm
beforeEach(() => {
el = document.createElement('div')
document.body.appendChild(el)
})
afterEach(() => {
// document.body.removeChild(el)
vm.$destroy()
})
it('should render correct contents', () => {
vm = new Vue({
el,
template: '<c-avatar>PLATO</c-avatar>',
components: {
CAvatar
}
})
expect(vm.$children.length).to.equal(1)
expect(vm.$children[0].$el.textContent).to.equal('PLATO')
})
})
|
/**
* @author v.lugovsky
* created on 16.12.2015
*/
(function () {
'use strict';
angular.module('BlurAdmin.pages.tables')
.controller('TablesPageCtrl', TablesPageCtrl);
/** @ngInject */
function TablesPageCtrl($scope, $filter, editableOptions, editableThemes) {
$scope.smartTablePageSize = 10;
$scope.smartTableData = [
{
id: 1,
firstName: 'Mark',
lastName: 'Otto',
username: '@mdo',
email: 'mdo@gmail.com',
age: '28'
},
{
id: 2,
firstName: 'Jacob',
lastName: 'Thornton',
username: '@fat',
email: 'fat@yandex.ru',
age: '45'
},
{
id: 3,
firstName: 'Larry',
lastName: 'Bird',
username: '@twitter',
email: 'twitter@outlook.com',
age: '18'
},
{
id: 4,
firstName: 'John',
lastName: 'Snow',
username: '@snow',
email: 'snow@gmail.com',
age: '20'
},
{
id: 5,
firstName: 'Jack',
lastName: 'Sparrow',
username: '@jack',
email: 'jack@yandex.ru',
age: '30'
},
{
id: 6,
firstName: 'Ann',
lastName: 'Smith',
username: '@ann',
email: 'ann@gmail.com',
age: '21'
},
{
id: 7,
firstName: 'Barbara',
lastName: 'Black',
username: '@barbara',
email: 'barbara@yandex.ru',
age: '43'
},
{
id: 8,
firstName: 'Sevan',
lastName: 'Bagrat',
username: '@sevan',
email: 'sevan@outlook.com',
age: '13'
},
{
id: 9,
firstName: 'Ruben',
lastName: 'Vardan',
username: '@ruben',
email: 'ruben@gmail.com',
age: '22'
},
{
id: 10,
firstName: 'Karen',
lastName: 'Sevan',
username: '@karen',
email: 'karen@yandex.ru',
age: '33'
},
{
id: 11,
firstName: 'Mark',
lastName: 'Otto',
username: '@mark',
email: 'mark@gmail.com',
age: '38'
},
{
id: 12,
firstName: 'Jacob',
lastName: 'Thornton',
username: '@jacob',
email: 'jacob@yandex.ru',
age: '48'
},
{
id: 13,
firstName: 'Haik',
lastName: 'Hakob',
username: '@haik',
email: 'haik@outlook.com',
age: '48'
},
{
id: 14,
firstName: 'Garegin',
lastName: 'Jirair',
username: '@garegin',
email: 'garegin@gmail.com',
age: '40'
},
{
id: 15,
firstName: 'Krikor',
lastName: 'Bedros',
username: '@krikor',
email: 'krikor@yandex.ru',
age: '32'
},
{
"id": 16,
"firstName": "Francisca",
"lastName": "Brady",
"username": "@Gibson",
"email": "franciscagibson@comtours.com",
"age": 11
},
{
"id": 17,
"firstName": "Tillman",
"lastName": "Figueroa",
"username": "@Snow",
"email": "tillmansnow@comtours.com",
"age": 34
},
{
"id": 18,
"firstName": "Jimenez",
"lastName": "Morris",
"username": "@Bryant",
"email": "jimenezbryant@comtours.com",
"age": 45
},
{
"id": 19,
"firstName": "Sandoval",
"lastName": "Jacobson",
"username": "@Mcbride",
"email": "sandovalmcbride@comtours.com",
"age": 32
},
{
"id": 20,
"firstName": "Griffin",
"lastName": "Torres",
"username": "@Charles",
"email": "griffincharles@comtours.com",
"age": 19
},
{
"id": 21,
"firstName": "Cora",
"lastName": "Parker",
"username": "@Caldwell",
"email": "coracaldwell@comtours.com",
"age": 27
},
{
"id": 22,
"firstName": "Cindy",
"lastName": "Bond",
"username": "@Velez",
"email": "cindyvelez@comtours.com",
"age": 24
},
{
"id": 23,
"firstName": "Frieda",
"lastName": "Tyson",
"username": "@Craig",
"email": "friedacraig@comtours.com",
"age": 45
},
{
"id": 24,
"firstName": "Cote",
"lastName": "Holcomb",
"username": "@Rowe",
"email": "coterowe@comtours.com",
"age": 20
},
{
"id": 25,
"firstName": "Trujillo",
"lastName": "Mejia",
"username": "@Valenzuela",
"email": "trujillovalenzuela@comtours.com",
"age": 16
},
{
"id": 26,
"firstName": "Pruitt",
"lastName": "Shepard",
"username": "@Sloan",
"email": "pruittsloan@comtours.com",
"age": 44
},
{
"id": 27,
"firstName": "Sutton",
"lastName": "Ortega",
"username": "@Black",
"email": "suttonblack@comtours.com",
"age": 42
},
{
"id": 28,
"firstName": "Marion",
"lastName": "Heath",
"username": "@Espinoza",
"email": "marionespinoza@comtours.com",
"age": 47
},
{
"id": 29,
"firstName": "Newman",
"lastName": "Hicks",
"username": "@Keith",
"email": "newmankeith@comtours.com",
"age": 15
},
{
"id": 30,
"firstName": "Boyle",
"lastName": "Larson",
"username": "@Summers",
"email": "boylesummers@comtours.com",
"age": 32
},
{
"id": 31,
"firstName": "Haynes",
"lastName": "Vinson",
"username": "@Mckenzie",
"email": "haynesmckenzie@comtours.com",
"age": 15
},
{
"id": 32,
"firstName": "Miller",
"lastName": "Acosta",
"username": "@Young",
"email": "milleryoung@comtours.com",
"age": 55
},
{
"id": 33,
"firstName": "Johnston",
"lastName": "Brown",
"username": "@Knight",
"email": "johnstonknight@comtours.com",
"age": 29
},
{
"id": 34,
"firstName": "Lena",
"lastName": "Pitts",
"username": "@Forbes",
"email": "lenaforbes@comtours.com",
"age": 25
},
{
"id": 35,
"firstName": "Terrie",
"lastName": "Kennedy",
"username": "@Branch",
"email": "terriebranch@comtours.com",
"age": 37
},
{
"id": 36,
"firstName": "Louise",
"lastName": "Aguirre",
"username": "@Kirby",
"email": "louisekirby@comtours.com",
"age": 44
},
{
"id": 37,
"firstName": "David",
"lastName": "Patton",
"username": "@Sanders",
"email": "davidsanders@comtours.com",
"age": 26
},
{
"id": 38,
"firstName": "Holden",
"lastName": "Barlow",
"username": "@Mckinney",
"email": "holdenmckinney@comtours.com",
"age": 11
},
{
"id": 39,
"firstName": "Baker",
"lastName": "Rivera",
"username": "@Montoya",
"email": "bakermontoya@comtours.com",
"age": 47
},
{
"id": 40,
"firstName": "Belinda",
"lastName": "Lloyd",
"username": "@Calderon",
"email": "belindacalderon@comtours.com",
"age": 21
},
{
"id": 41,
"firstName": "Pearson",
"lastName": "Patrick",
"username": "@Clements",
"email": "pearsonclements@comtours.com",
"age": 42
},
{
"id": 42,
"firstName": "Alyce",
"lastName": "Mckee",
"username": "@Daugherty",
"email": "alycedaugherty@comtours.com",
"age": 55
},
{
"id": 43,
"firstName": "Valencia",
"lastName": "Spence",
"username": "@Olsen",
"email": "valenciaolsen@comtours.com",
"age": 20
},
{
"id": 44,
"firstName": "Leach",
"lastName": "Holcomb",
"username": "@Humphrey",
"email": "leachhumphrey@comtours.com",
"age": 28
},
{
"id": 45,
"firstName": "Moss",
"lastName": "Baxter",
"username": "@Fitzpatrick",
"email": "mossfitzpatrick@comtours.com",
"age": 51
},
{
"id": 46,
"firstName": "Jeanne",
"lastName": "Cooke",
"username": "@Ward",
"email": "jeanneward@comtours.com",
"age": 59
},
{
"id": 47,
"firstName": "Wilma",
"lastName": "Briggs",
"username": "@Kidd",
"email": "wilmakidd@comtours.com",
"age": 53
},
{
"id": 48,
"firstName": "Beatrice",
"lastName": "Perry",
"username": "@Gilbert",
"email": "beatricegilbert@comtours.com",
"age": 39
},
{
"id": 49,
"firstName": "Whitaker",
"lastName": "Hyde",
"username": "@Mcdonald",
"email": "whitakermcdonald@comtours.com",
"age": 35
},
{
"id": 50,
"firstName": "Rebekah",
"lastName": "Duran",
"username": "@Gross",
"email": "rebekahgross@comtours.com",
"age": 40
},
{
"id": 51,
"firstName": "Earline",
"lastName": "Mayer",
"username": "@Woodward",
"email": "earlinewoodward@comtours.com",
"age": 52
},
{
"id": 52,
"firstName": "Moran",
"lastName": "Baxter",
"username": "@Johns",
"email": "moranjohns@comtours.com",
"age": 20
},
{
"id": 53,
"firstName": "Nanette",
"lastName": "Hubbard",
"username": "@Cooke",
"email": "nanettecooke@comtours.com",
"age": 55
},
{
"id": 54,
"firstName": "Dalton",
"lastName": "Walker",
"username": "@Hendricks",
"email": "daltonhendricks@comtours.com",
"age": 25
},
{
"id": 55,
"firstName": "Bennett",
"lastName": "Blake",
"username": "@Pena",
"email": "bennettpena@comtours.com",
"age": 13
},
{
"id": 56,
"firstName": "Kellie",
"lastName": "Horton",
"username": "@Weiss",
"email": "kellieweiss@comtours.com",
"age": 48
},
{
"id": 57,
"firstName": "Hobbs",
"lastName": "Talley",
"username": "@Sanford",
"email": "hobbssanford@comtours.com",
"age": 28
},
{
"id": 58,
"firstName": "Mcguire",
"lastName": "Donaldson",
"username": "@Roman",
"email": "mcguireroman@comtours.com",
"age": 38
},
{
"id": 59,
"firstName": "Rodriquez",
"lastName": "Saunders",
"username": "@Harper",
"email": "rodriquezharper@comtours.com",
"age": 20
},
{
"id": 60,
"firstName": "Lou",
"lastName": "Conner",
"username": "@Sanchez",
"email": "lousanchez@comtours.com",
"age": 16
}
];
$scope.editableTableData = $scope.smartTableData.slice(0, 36);
$scope.peopleTableData = [
{
id: 1,
firstName: 'Mark',
lastName: 'Otto',
username: '@mdo',
email: 'mdo@gmail.com',
age: '28',
status: 'info'
},
{
id: 2,
firstName: 'Jacob',
lastName: 'Thornton',
username: '@fat',
email: 'fat@yandex.ru',
age: '45',
status: 'primary'
},
{
id: 3,
firstName: 'Larry',
lastName: 'Bird',
username: '@twitter',
email: 'twitter@outlook.com',
age: '18',
status: 'success'
},
{
id: 4,
firstName: 'John',
lastName: 'Snow',
username: '@snow',
email: 'snow@gmail.com',
age: '20',
status: 'danger'
},
{
id: 5,
firstName: 'Jack',
lastName: 'Sparrow',
username: '@jack',
email: 'jack@yandex.ru',
age: '30',
status: 'warning'
}
];
$scope.metricsTableData = [
{
image: 'app/browsers/chrome.svg',
browser: 'Google Chrome',
visits: '10,392',
isVisitsUp: true,
purchases: '4,214',
isPurchasesUp: true,
percent: '45%',
isPercentUp: true
},
{
image: 'app/browsers/firefox.svg',
browser: 'Mozilla Firefox',
visits: '7,873',
isVisitsUp: true,
purchases: '3,031',
isPurchasesUp: false,
percent: '28%',
isPercentUp: true
},
{
image: 'app/browsers/ie.svg',
browser: 'Internet Explorer',
visits: '5,890',
isVisitsUp: false,
purchases: '2,102',
isPurchasesUp: false,
percent: '17%',
isPercentUp: false
},
{
image: 'app/browsers/safari.svg',
browser: 'Safari',
visits: '4,001',
isVisitsUp: false,
purchases: '1,001',
isPurchasesUp: false,
percent: '14%',
isPercentUp: true
},
{
image: 'app/browsers/opera.svg',
browser: 'Opera',
visits: '1,833',
isVisitsUp: true,
purchases: '83',
isPurchasesUp: true,
percent: '5%',
isPercentUp: false
}
];
$scope.users = [
{
"id": 1,
"name": "Esther Vang",
"status": 4,
"group": 3
},
{
"id": 2,
"name": "Leah Freeman",
"status": 3,
"group": 1
},
{
"id": 3,
"name": "Mathews Simpson",
"status": 3,
"group": 2
},
{
"id": 4,
"name": "Buckley Hopkins",
"group": 4
},
{
"id": 5,
"name": "Buckley Schwartz",
"status": 1,
"group": 1
},
{
"id": 6,
"name": "Mathews Hopkins",
"status": 4,
"group": 2
},
{
"id": 7,
"name": "Leah Vang",
"status": 4,
"group": 1
},
{
"id": 8,
"name": "Vang Schwartz",
"status": 4,
"group": 2
},
{
"id": 9,
"name": "Hopkin Esther",
"status": 1,
"group": 2
},
{
"id": 10,
"name": "Mathews Schwartz",
"status": 1,
"group": 3
}
];
$scope.statuses = [
{value: 1, text: 'Good'},
{value: 2, text: 'Awesome'},
{value: 3, text: 'Excellent'},
];
$scope.groups = [
{id: 1, text: 'user'},
{id: 2, text: 'customer'},
{id: 3, text: 'vip'},
{id: 4, text: 'admin'}
];
$scope.showGroup = function (user) {
if (user.group && $scope.groups.length) {
var selected = $filter('filter')($scope.groups, {id: user.group});
return selected.length ? selected[0].text : 'Not set';
} else return 'Not set'
};
$scope.showStatus = function (user) {
var selected = [];
if (user.status) {
selected = $filter('filter')($scope.statuses, {value: user.status});
}
return selected.length ? selected[0].text : 'Not set';
};
$scope.removeUser = function (index) {
$scope.users.splice(index, 1);
};
$scope.addUser = function () {
$scope.inserted = {
id: $scope.users.length + 1,
name: '',
status: null,
group: null
};
$scope.users.push($scope.inserted);
};
editableOptions.theme = 'bs3';
editableThemes['bs3'].submitTpl = '<button type="submit" class="btn btn-primary btn-with-icon"><i class="ion-checkmark-round"></i></button>';
editableThemes['bs3'].cancelTpl = '<button type="button" ng-click="$form.$cancel()" class="btn btn-default btn-with-icon"><i class="ion-close-round"></i></button>';
}
})();
|
/*
Copyright (c) 2003-2016, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'find', 'en-au', {
find: 'Find',
findOptions: 'Find Options',
findWhat: 'Find what:',
matchCase: 'Match case',
matchCyclic: 'Match cyclic',
matchWord: 'Match whole word',
notFoundMsg: 'The specified text was not found.',
replace: 'Replace',
replaceAll: 'Replace All',
replaceSuccessMsg: '%1 occurrence(s) replaced.',
replaceWith: 'Replace with:',
title: 'Find and Replace'
} );
|
var fs = require('fs');
var path = require('path');
var gulp = require('gulp');
// Load all gulp plugins automatically
// and attach them to the `plugins` object
var plugins = require('gulp-load-plugins')();
// Temporary solution until gulp 4
// https://github.com/gulpjs/gulp/issues/355
var runSequence = require('run-sequence');
var pkg = require('./package.json');
var dirs = pkg['h5bp-configs'].directories;
// ---------------------------------------------------------------------
// | Helper tasks |
// ---------------------------------------------------------------------
gulp.task('archive:create_archive_dir', function () {
fs.mkdirSync(path.resolve(dirs.archive), '0755');
});
gulp.task('archive:zip', function (done) {
var archiveName = path.resolve(dirs.archive, pkg.name + '_v' + pkg.version + '.zip');
var archiver = require('archiver')('zip');
var files = require('glob').sync('**/*.*', {
'cwd': dirs.dist,
'dot': true // include hidden files
});
var output = fs.createWriteStream(archiveName);
archiver.on('error', function (error) {
done();
throw error;
});
output.on('close', done);
files.forEach(function (file) {
var filePath = path.resolve(dirs.dist, file);
// `archiver.bulk` does not maintain the file
// permissions, so we need to add files individually
archiver.append(fs.createReadStream(filePath), {
'name': file,
'mode': fs.statSync(filePath).mode
});
});
archiver.pipe(output);
archiver.finalize();
});
gulp.task('clean', function (done) {
require('del')([
dirs.archive,
dirs.dist
]).then(function () {
done();
});
});
gulp.task('s3', function () {
var s3 = require("gulp-s3");
var aws = JSON.parse(fs.readFileSync('./aws.json'));
gulp.src('./dist/**').pipe(s3(aws));
});
gulp.task('copy', [
'copy:.htaccess',
'copy:index.html',
'copy:jquery',
'copy:license',
'copy:main.css',
'copy:misc',
'copy:normalize'
]);
gulp.task('copy:.htaccess', function () {
return gulp.src('node_modules/apache-server-configs/dist/.htaccess')
.pipe(plugins.replace(/# ErrorDocument/g, 'ErrorDocument'))
.pipe(gulp.dest(dirs.dist));
});
gulp.task('copy:index.html', function () {
return gulp.src(dirs.src + '/index.html')
.pipe(plugins.replace(/{{JQUERY_VERSION}}/g, pkg.devDependencies.jquery))
.pipe(gulp.dest(dirs.dist));
});
gulp.task('copy:jquery', function () {
return gulp.src(['node_modules/jquery/dist/jquery.min.js'])
.pipe(plugins.rename('jquery-' + pkg.devDependencies.jquery + '.min.js'))
.pipe(gulp.dest(dirs.dist + '/js/vendor'));
});
gulp.task('copy:license', function () {
return gulp.src('LICENSE.txt')
.pipe(gulp.dest(dirs.dist));
});
gulp.task('copy:main.css', function () {
var banner = '/*! HTML5 Boilerplate v' + pkg.version +
' | ' + pkg.license.type + ' License' +
' | ' + pkg.homepage + ' */\n\n';
return gulp.src(dirs.src + '/css/main.css')
.pipe(plugins.header(banner))
.pipe(plugins.autoprefixer({
browsers: ['last 2 versions', 'ie >= 8', '> 1%'],
cascade: false
}))
.pipe(gulp.dest(dirs.dist + '/css'));
});
gulp.task('copy:misc', function () {
return gulp.src([
// Copy all files
dirs.src + '/**/*',
// Exclude the following files
// (other tasks will handle the copying of these files)
'!' + dirs.src + '/css/main.css',
'!' + dirs.src + '/index.html'
], {
// Include hidden files by default
dot: true
}).pipe(gulp.dest(dirs.dist));
});
gulp.task('copy:normalize', function () {
return gulp.src('node_modules/normalize.css/normalize.css')
.pipe(gulp.dest(dirs.dist + '/css'));
});
gulp.task('lint:js', function () {
return gulp.src([
'gulpfile.js',
//dirs.src + '/js/*.js',
dirs.test + '/*.js'
]).pipe(plugins.jscs())
.pipe(plugins.jshint())
.pipe(plugins.jshint.reporter('jshint-stylish'))
.pipe(plugins.jshint.reporter('fail'));
});
// ---------------------------------------------------------------------
// | Main tasks |
// ---------------------------------------------------------------------
gulp.task('archive', function (done) {
runSequence(
'build',
'archive:create_archive_dir',
'archive:zip',
done);
});
gulp.task('build', function (done) {
runSequence(
['clean', 'lint:js'],
'copy',
done);
});
gulp.task('default', ['build']);
|
$(document).ready(function() {
// Adjust the width of images to fill the
// maximum space available
$('.post-content-uber p').each(function(i){ // For each paragraph
if ( ($(this).find('img').length) && // If there's an image
(!$.trim($(this).text()).length)) // and there's no text
{
$(this).addClass('image-only-uber'); // Add a special CSS class
}
});
// Add figcaption under an image
$(".post-content-uber img").each(function() {
if($(this).attr("caption")){
$(this).wrap('<figure class="image"></figure>')
.after('<figcaption>'+$(this).attr("caption")+'</figcaption>');
}
});
}); |
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = maAddressColumn;
function maAddressColumn() {
return {
restrict: 'E',
scope: {
entry: '=',
field: '&',
value: '&'
},
link: function link(scope) {
var field = scope.field();
scope.name = field.name();
scope.address_street = scope.entry.values[scope.name];
},
template: '\n <span> {{ address_street }} </span>\n '
};
}
maAddressColumn.$inject = [];
module.exports = exports['default'];
//# sourceMappingURL=maAddressColumn.js.map |
version https://git-lfs.github.com/spec/v1
oid sha256:0046626ac81a629a20efcfe5eff9fd48f9e889f2b19e37af8bb4214f8942e15f
size 15239
|
var searchData=
[
['sendmsg',['sendMsg',['../class_connection.html#a4b9f6db1fb42fc9857f829fa0bc52e6e',1,'Connection']]],
['setbackground',['setBackground',['../class_graph_viewer.html#a02437b5fecd8b90de24436068312d593',1,'GraphViewer']]],
['setedgecolor',['setEdgeColor',['../class_graph_viewer.html#a07ccc96707efae4aa5f3ced3dca015af',1,'GraphViewer']]],
['setedgedashed',['setEdgeDashed',['../class_graph_viewer.html#a1698f1c6b3a8e7cabc7b7d7cf42fc7f0',1,'GraphViewer']]],
['setedgeflow',['setEdgeFlow',['../class_graph_viewer.html#a69eb065145063e4dea41961e92e35c8e',1,'GraphViewer']]],
['setedgelabel',['setEdgeLabel',['../class_graph_viewer.html#a447cca0064e785654c2105602c2961ca',1,'GraphViewer']]],
['setedgethickness',['setEdgeThickness',['../class_graph_viewer.html#a07f598272fe3515455eab13be749604a',1,'GraphViewer']]],
['setedgeweight',['setEdgeWeight',['../class_graph_viewer.html#ac211de009a0afe2e6d44f4f8d030a2cc',1,'GraphViewer']]],
['setvertexcolor',['setVertexColor',['../class_graph_viewer.html#a8b542d7e09e81a45a74760c19233beb0',1,'GraphViewer']]],
['setvertexicon',['setVertexIcon',['../class_graph_viewer.html#a02d5f7393eab9a2d1b66719039597a64',1,'GraphViewer']]],
['setvertexlabel',['setVertexLabel',['../class_graph_viewer.html#ac25d7d007022fda16799808ba136e909',1,'GraphViewer']]],
['setvertexsize',['setVertexSize',['../class_graph_viewer.html#ae930dfdfcdeb7a871eefb6028d74b9f9',1,'GraphViewer']]]
];
|
var Promise = require('../promise.js');
module.exports = {
deferred: function () {
var deferred = {};
deferred.promise = new Promise(function (resolve, reject) {
deferred.resolve = resolve;
deferred.reject = reject;
});
return deferred;
},
resolved: function (value) {
return Promise.resolve(value);
},
rejected: function (reason) {
return Promise.reject(reason);
}
};
|
'use strict';
angular.module('tvApp')
.config(function ($stateProvider) {
$stateProvider
.state('main', {
url: '/',
templateUrl: 'app/main/main.html',
controller: 'MainCtrl'
});
}); |
var path = require('path');
var url = require("url");
var siteConfig = require("./configs/siteConfig");
function route(req, res, next) {
var pathinfo = url.parse(req.url).pathname.split("/");
var ctrlname = pathinfo[1] == '' ? siteConfig.defaultCtrl : pathinfo[1];
var action = typeof(pathinfo[2]) == 'undefined' ? siteConfig.defaultAction : pathinfo[2];
try {
if (ctrlname == 'diyroute') {
var ctrl = new (require('./ctrl/1234'))(req,res);
ctrl[action](req, res);
} else if (ctrlname == 'statics') {
var ctrl = new require('./ctrl/statics');
ctrl(req, res);
} else {
var ctrl = new (require('./ctrl/' + ctrlname))(req,res);
ctrl[action](function(err) {
next();
});
}
} catch (e) {
console.log(e);
var ctrl = new (require('./ctrl/error'));
ctrl._404(req, res);
}
}
exports.route = route; |
define (
[
],
function (createjs) {
// Convert all displayobject.mask shapes with alphafilters
var AlphaMaskFilter = function (createjs) {
var alphaMaskFilter = this;
this.createjs = createjs;
Object.defineProperty (
createjs.DisplayObject.prototype,
'mask',
{
'get' : function () {
//return this.originalMask;
return this.forceMask;
},
'set' : function (mask) {
var self = this;
if (mask) {
self.originalMask = mask;
var filter = alphaMaskFilter.getFilterFromMask(mask, self);
// Instead of assigning the mask, assign a filter.
self.filters = [
filter
];
self.cache(0, 0, 500, 500);
}
else if (mask !== null) {
self.filters = null;
self.cache(0, 0, 500, 500);
}
}
}
);
// Override method.
createjs.DisplayObject.prototype.setMask = function (mask) {
this.forceMask = mask;
};
};
var p = AlphaMaskFilter.prototype;
p.getFilterFromMask = function (mask, parent) {
var createjs = this.createjs;
// Redraw the graphics.
var instructions = mask.graphics.getInstructions ();
var g = new createjs.Graphics;
g.beginFill ('#000000');
g.beginStroke ('#000000');
for (var i = 0; i < instructions.length; i ++) {
g.append (instructions[i]);
}
mask.graphics = g;
// Create a container.
var subcontainer = new createjs.Container();
subcontainer.addChild (mask);
subcontainer.scaleX = 1 / parent.scaleX;
subcontainer.scaleY = 1 / parent.scaleY;
subcontainer.y = -parent.y;
subcontainer.x = -parent.x;
var container = new createjs.Container ();
container.addChild (subcontainer);
// Cache this shit.
container.cache (0, 0, 1000, 1000);
return new createjs.AlphaMaskFilter(container.cacheCanvas);
};
return AlphaMaskFilter;
}
); |
/**
@module ember-data
*/
import Ember from 'ember';
var get = Ember.get;
/**
An adapter is an object that receives requests from a store and
translates them into the appropriate action to take against your
persistence layer. The persistence layer is usually an HTTP API, but
may be anything, such as the browser's local storage. Typically the
adapter is not invoked directly instead its functionality is accessed
through the `store`.
### Creating an Adapter
Create a new subclass of `DS.Adapter` in the `app/adapters` folder:
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
// ...your code here
});
```
Model-specific adapters can be created by putting your adapter
class in an `app/adapters/` + `model-name` + `.js` file of the application.
```app/adapters/post.js
import DS from 'ember-data';
export default DS.Adapter.extend({
// ...Post-specific adapter code goes here
});
```
`DS.Adapter` is an abstract base class that you should override in your
application to customize it for your backend. The minimum set of methods
that you should implement is:
* `findRecord()`
* `createRecord()`
* `updateRecord()`
* `deleteRecord()`
* `findAll()`
* `query()`
To improve the network performance of your application, you can optimize
your adapter by overriding these lower-level methods:
* `findMany()`
For an example implementation, see `DS.RESTAdapter`, the
included REST adapter.
@class Adapter
@namespace DS
@extends Ember.Object
*/
export default Ember.Object.extend({
/**
If you would like your adapter to use a custom serializer you can
set the `defaultSerializer` property to be the name of the custom
serializer.
Note the `defaultSerializer` serializer has a lower priority than
a model specific serializer (i.e. `PostSerializer`) or the
`application` serializer.
```app/adapters/django.js
import DS from 'ember-data';
export default DS.Adapter.extend({
defaultSerializer: 'django'
});
```
@property defaultSerializer
@type {String}
*/
defaultSerializer: '-default',
/**
The `findRecord()` method is invoked when the store is asked for a record that
has not previously been loaded. In response to `findRecord()` being called, you
should query your persistence layer for a record with the given ID. The `findRecord`
method should return a promise that will resolve to a JavaScript object that will be
normalized by the serializer.
Here is an example `findRecord` implementation:
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
findRecord: function(store, type, id, snapshot) {
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.getJSON(`/${type.modelName}/${id}`).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method findRecord
@param {DS.Store} store
@param {DS.Model} type
@param {String} id
@param {DS.Snapshot} snapshot
@return {Promise} promise
*/
findRecord: null,
/**
The `findAll()` method is used to retrieve all records for a given type.
Example
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
findAll: function(store, type, sinceToken) {
var query = { since: sinceToken };
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.getJSON(`/${type.modelName}`, query).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method findAll
@param {DS.Store} store
@param {DS.Model} type
@param {String} sinceToken
@param {DS.SnapshotRecordArray} snapshotRecordArray
@return {Promise} promise
*/
findAll: null,
/**
This method is called when you call `query` on the store.
Example
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
query: function(store, type, query) {
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.getJSON(`/${type.modelName}`, query).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method query
@param {DS.Store} store
@param {DS.Model} type
@param {Object} query
@param {DS.AdapterPopulatedRecordArray} recordArray
@return {Promise} promise
*/
query: null,
/**
The `queryRecord()` method is invoked when the store is asked for a single
record through a query object.
In response to `queryRecord()` being called, you should always fetch fresh
data. Once found, you can asynchronously call the store's `push()` method
to push the record into the store.
Here is an example `queryRecord` implementation:
Example
```app/adapters/application.js
import DS from 'ember-data';
import Ember from 'ember';
export default DS.Adapter.extend(DS.BuildURLMixin, {
queryRecord: function(store, type, query) {
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.getJSON(`/${type.modelName}`, query).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method queryRecord
@param {DS.Store} store
@param {subclass of DS.Model} type
@param {Object} query
@return {Promise} promise
*/
queryRecord: null,
/**
If the globally unique IDs for your records should be generated on the client,
implement the `generateIdForRecord()` method. This method will be invoked
each time you create a new record, and the value returned from it will be
assigned to the record's `primaryKey`.
Most traditional REST-like HTTP APIs will not use this method. Instead, the ID
of the record will be set by the server, and your adapter will update the store
with the new ID when it calls `didCreateRecord()`. Only implement this method if
you intend to generate record IDs on the client-side.
The `generateIdForRecord()` method will be invoked with the requesting store as
the first parameter and the newly created record as the second parameter:
```javascript
import DS from 'ember-data';
import { v4 } from 'uuid';
export default DS.Adapter.extend({
generateIdForRecord: function(store, inputProperties) {
return v4();
}
});
```
@method generateIdForRecord
@param {DS.Store} store
@param {DS.Model} type the DS.Model class of the record
@param {Object} inputProperties a hash of properties to set on the
newly created record.
@return {(String|Number)} id
*/
generateIdForRecord: null,
/**
Proxies to the serializer's `serialize` method.
Example
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
createRecord: function(store, type, snapshot) {
var data = this.serialize(snapshot, { includeId: true });
var url = `/${type.modelName}`;
// ...
}
});
```
@method serialize
@param {DS.Snapshot} snapshot
@param {Object} options
@return {Object} serialized snapshot
*/
serialize(snapshot, options) {
return get(snapshot.record, 'store').serializerFor(snapshot.modelName).serialize(snapshot, options);
},
/**
Implement this method in a subclass to handle the creation of
new records.
Serializes the record and sends it to the server.
Example
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
createRecord: function(store, type, snapshot) {
var data = this.serialize(snapshot, { includeId: true });
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.ajax({
type: 'POST',
url: `/${type.modelName}`,
dataType: 'json',
data: data
}).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method createRecord
@param {DS.Store} store
@param {DS.Model} type the DS.Model class of the record
@param {DS.Snapshot} snapshot
@return {Promise} promise
*/
createRecord: null,
/**
Implement this method in a subclass to handle the updating of
a record.
Serializes the record update and sends it to the server.
The updateRecord method is expected to return a promise that will
resolve with the serialized record. This allows the backend to
inform the Ember Data store the current state of this record after
the update. If it is not possible to return a serialized record
the updateRecord promise can also resolve with `undefined` and the
Ember Data store will assume all of the updates were successfully
applied on the backend.
Example
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
updateRecord: function(store, type, snapshot) {
var data = this.serialize(snapshot, { includeId: true });
var id = snapshot.id;
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.ajax({
type: 'PUT',
url: `/${type.modelName}/${id}`,
dataType: 'json',
data: data
}).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method updateRecord
@param {DS.Store} store
@param {DS.Model} type the DS.Model class of the record
@param {DS.Snapshot} snapshot
@return {Promise} promise
*/
updateRecord: null,
/**
Implement this method in a subclass to handle the deletion of
a record.
Sends a delete request for the record to the server.
Example
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
deleteRecord: function(store, type, snapshot) {
var data = this.serialize(snapshot, { includeId: true });
var id = snapshot.id;
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.ajax({
type: 'DELETE',
url: `/${type.modelName}/${id}`,
dataType: 'json',
data: data
}).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method deleteRecord
@param {DS.Store} store
@param {DS.Model} type the DS.Model class of the record
@param {DS.Snapshot} snapshot
@return {Promise} promise
*/
deleteRecord: null,
/**
By default the store will try to coalesce all `fetchRecord` calls within the same runloop
into as few requests as possible by calling groupRecordsForFindMany and passing it into a findMany call.
You can opt out of this behaviour by either not implementing the findMany hook or by setting
coalesceFindRequests to false.
@property coalesceFindRequests
@type {boolean}
*/
coalesceFindRequests: true,
/**
The store will call `findMany` instead of multiple `findRecord`
requests to find multiple records at once if coalesceFindRequests
is true.
```app/adapters/application.js
import DS from 'ember-data';
export default DS.Adapter.extend({
findMany(store, type, ids, snapshots) {
return new Ember.RSVP.Promise(function(resolve, reject) {
Ember.$.ajax({
type: 'GET',
url: `/${type.modelName}/`,
dataType: 'json',
data: { filter: { id: ids.join(',') } }
}).then(function(data) {
Ember.run(null, resolve, data);
}, function(jqXHR) {
jqXHR.then = null; // tame jQuery's ill mannered promises
Ember.run(null, reject, jqXHR);
});
});
}
});
```
@method findMany
@param {DS.Store} store
@param {DS.Model} type the DS.Model class of the records
@param {Array} ids
@param {Array} snapshots
@return {Promise} promise
*/
findMany: null,
/**
Organize records into groups, each of which is to be passed to separate
calls to `findMany`.
For example, if your api has nested URLs that depend on the parent, you will
want to group records by their parent.
The default implementation returns the records as a single group.
@method groupRecordsForFindMany
@param {DS.Store} store
@param {Array} snapshots
@return {Array} an array of arrays of records, each of which is to be
loaded separately by `findMany`.
*/
groupRecordsForFindMany(store, snapshots) {
return [snapshots];
},
/**
This method is used by the store to determine if the store should
reload a record from the adapter when a record is requested by
`store.findRecord`.
If this method returns `true`, the store will re-fetch a record from
the adapter. If this method returns `false`, the store will resolve
immediately using the cached record.
For example, if you are building an events ticketing system, in which users
can only reserve tickets for 20 minutes at a time, and want to ensure that
in each route you have data that is no more than 20 minutes old you could
write:
```javascript
shouldReloadRecord: function(store, ticketSnapshot) {
var timeDiff = moment().diff(ticketSnapshot.attr('lastAccessedAt')).minutes();
if (timeDiff > 20) {
return true;
} else {
return false;
}
}
```
This method would ensure that whenever you do `store.findRecord('ticket',
id)` you will always get a ticket that is no more than 20 minutes old. In
case the cached version is more than 20 minutes old, `findRecord` will not
resolve until you fetched the latest version.
By default this hook returns `false`, as most UIs should not block user
interactions while waiting on data update.
@method shouldReloadRecord
@param {DS.Store} store
@param {DS.Snapshot} snapshot
@return {Boolean}
*/
shouldReloadRecord(store, snapshot) {
return false;
},
/**
This method is used by the store to determine if the store should
reload all records from the adapter when records are requested by
`store.findAll`.
If this method returns `true`, the store will re-fetch all records from
the adapter. If this method returns `false`, the store will resolve
immediately using the cached records.
For example, if you are building an events ticketing system, in which users
can only reserve tickets for 20 minutes at a time, and want to ensure that
in each route you have data that is no more than 20 minutes old you could
write:
```javascript
shouldReloadAll: function(store, snapshotArray) {
var snapshots = snapshotArray.snapshots();
return snapshots.any(function(ticketSnapshot) {
var timeDiff = moment().diff(ticketSnapshot.attr('lastAccessedAt')).minutes();
if (timeDiff > 20) {
return true;
} else {
return false;
}
});
}
```
This method would ensure that whenever you do `store.findAll('ticket')` you
will always get a list of tickets that are no more than 20 minutes old. In
case a cached version is more than 20 minutes old, `findAll` will not
resolve until you fetched the latest versions.
By default this methods returns `true` if the passed `snapshotRecordArray`
is empty (meaning that there are no records locally available yet),
otherwise it returns `false`.
@method shouldReloadAll
@param {DS.Store} store
@param {DS.SnapshotRecordArray} snapshotRecordArray
@return {Boolean}
*/
shouldReloadAll(store, snapshotRecordArray) {
return !snapshotRecordArray.length;
},
/**
This method is used by the store to determine if the store should
reload a record after the `store.findRecord` method resolves a
cached record.
This method is *only* checked by the store when the store is
returning a cached record.
If this method returns `true` the store will re-fetch a record from
the adapter.
For example, if you do not want to fetch complex data over a mobile
connection, or if the network is down, you can implement
`shouldBackgroundReloadRecord` as follows:
```javascript
shouldBackgroundReloadRecord: function(store, snapshot) {
var connection = window.navigator.connection;
if (connection === 'cellular' || connection === 'none') {
return false;
} else {
return true;
}
}
```
By default this hook returns `true` so the data for the record is updated
in the background.
@method shouldBackgroundReloadRecord
@param {DS.Store} store
@param {DS.Snapshot} snapshot
@return {Boolean}
*/
shouldBackgroundReloadRecord(store, snapshot) {
return true;
},
/**
This method is used by the store to determine if the store should
reload a record array after the `store.findAll` method resolves
with a cached record array.
This method is *only* checked by the store when the store is
returning a cached record array.
If this method returns `true` the store will re-fetch all records
from the adapter.
For example, if you do not want to fetch complex data over a mobile
connection, or if the network is down, you can implement
`shouldBackgroundReloadAll` as follows:
```javascript
shouldBackgroundReloadAll: function(store, snapshotArray) {
var connection = window.navigator.connection;
if (connection === 'cellular' || connection === 'none') {
return false;
} else {
return true;
}
}
```
By default this method returns `true`, indicating that a background reload
should always be triggered.
@method shouldBackgroundReloadAll
@param {DS.Store} store
@param {DS.SnapshotRecordArray} snapshotRecordArray
@return {Boolean}
*/
shouldBackgroundReloadAll(store, snapshotRecordArray) {
return true;
}
});
|
'use strict';
const assert = require('assert');
const del = require('del');
const extrakt = require('extrakt');
const mkdirp = require('make-dir');
const path = require('path');
const pathExists = require('path-exists');
const parseFilesize = require('filesize-parser');
const _ = require('lodash');
const EventEmitter = require('events').EventEmitter;
const Promise = require('bluebird');
const Query = require('./Query');
const Operation = require('./Operation');
const Result = require('./Result');
const RestoredFromCache = require('./RestoredFromCache');
const Index = require('./Index');
const Runner = require('./Runner');
const getRedundantResults = require('./util/getRedundantResults');
/**
* @event run({operation})
* Fired when no cached result is found and thus the callback is ran
*
* @event restore({result, operation})
* Fired when a cached result is found, before it's restored
*
* @event store({operation)}
* Fired after a cacheable operation has completed running, when the result is about to be stored
*
* @event sync()
* Fired when the index is refreshed / synchronised with the filesystem
*
* @event cleanup({current, allowed, removing})
* Fired when the cache exceeds the maximum allowed size and redundant results are removed from the index
*
* @event query({values})
* Fired when the cache index is queried
*
* @event saved({result, operation})
* Fired when a result was saved to the cache
*/
class Cache extends EventEmitter {
constructor({
compress = false,
workingDirectory = process.cwd(),
maxSize = '512mb',
workspace = null,
dataStore = null,
} = {}) {
super();
this.operationDefaults = {workingDirectory, compress};
this.workingDirectory = workingDirectory;
this.workspace = workspace || path.join(this.workingDirectory, '.johnny');
this.dataStore = dataStore || path.join(this.workspace, '.index.json');
this.maxSize = parseFilesize(maxSize);
this.index = new Index({filename: this.dataStore});
}
/**
* Makes sure the cache size does not exceed the maximum allowed size, removing the most irrelevant rows from the DB
* @param {Number} [freeUp = 0] The number of bytes to additionally clear up
* @returns {[]} The results that were removed
*/
maintainMaxSize(freeUp = 0) {
const docs = this.index.all();
const results = _.map(docs, doc => Result.fromDocument({}, doc));
const totalCacheSize = _.sumBy(results, result => result.fileSize) + freeUp;
const resultsToRemove = getRedundantResults(results, this.maxSize, totalCacheSize);
if (_.size(resultsToRemove)) {
this.emit('cleanup', {current: totalCacheSize, allowed: this.maxSize, removing: resultsToRemove});
this.removeResults(resultsToRemove);
}
return resultsToRemove;
}
/**
* Remove the given results from the index
* @param {Result[]} results
*/
removeResults(results) {
const ids = _.map(results, 'id');
return this.index.removeById(ids);
}
/**
* Returns a promise for the preparation of the cache
* @returns {Promise}
*/
awaitReady() {
if (!this.ready) this.ready = this.sync();
return this.ready;
}
/**
* Prepare the cache
* Runs some update / refresh operations (usually performed on instantiation)
* @returns {this}
*/
async sync() {
this.emit('sync');
if (!this.mkdirp) {
// Make sure the workspace directory exists
await mkdirp(this.workspace);
this.mkdirp = true;
}
// Synchronize the index database
await this.index.sync();
// Remove expired rows from the index
this.index.removeExpired();
// Remove irrelevant rows from the index if the max size is exceeded
this.maintainMaxSize();
// Delete all cache files that are not represented in the index
await this.purgeUntracked();
return this;
}
/**
* Remove files for which there is no related row in the index
* @returns {Promise}
*/
purgeUntracked() {
const docs = this.index.all();
const wildcard = path.join(this.workspace, '*.*');
const whitelist = _.map(docs, doc => `!${this.getAbsolutePath(doc.filename)}`);
return del([wildcard].concat(whitelist), {force: true});
}
/**
* Get the absolute path for the given file name
* @param {string} filename
* @return {string}
*/
getAbsolutePath(filename) {
assert(filename);
return path.join(this.workspace, filename);
}
/**
* Insert the given result into the index
* @param result
*/
insert(result) {
result.id = this.index.insert(result.toDocument()).id;
}
/**
* Restores the result for the given operation
* @param operation
* @returns {Promise.<RestoredFromCache>}
*/
async restore(operation) {
const result = await this.getResult(operation);
let start = Date.now();
this.emit('restore', {result, operation});
await extrakt(this.getAbsolutePath(result.filename), result.workingDirectory);
const runtime = Date.now() - start;
return new RestoredFromCache({result, runtime});
}
emitForward() {
this.emit('forward');
}
/**
* Try to find a cached result for the given operation
* @param {Operation} operation
* @returns {Result}
*/
async getResult(operation) {
const [query] = await Promise.all([
Query.fromOperation(operation),
this.awaitReady()
]);
this.emit('query', {query: query.constraints});
const doc = this.index.findOne(query.predicate);
return (doc && await pathExists(this.getAbsolutePath(doc.filename))) ?
Result.fromDocument(operation, doc) :
null;
}
/**
* Check whether there is a result available for the given intent
* @param {Operation} operation
* @returns {Promise.<boolean>}
*/
async hasResult(operation) {
return !!(await this.getResult(operation));
}
/**
* Convert the given intent to an operation
* @param {Intent} intent
* @returns {Operation}
*/
convertIntent(intent) {
return new Operation(intent.run, {...this.operationDefaults, ...intent.options});
}
/**
* @TODO we need a naming difference between "run" and "run"..
* This method will actually RUN the operation runner function
* Whereas "Cache.run" will either restore or run the operation
* @param operation
* @param args
* @returns {SavedToCache}
*/
runOperation(operation, ...args) {
return (new Runner({cache: this, operation})).run(...args);
}
/**
* Convert the given intent and run the resulting operation
* @param {Intent} intent
* @param args
* @returns {SavedToCache|RestoredFromCache|null}
*/
async run(intent, ...args) {
if (intent.isCacheable) {
const operation = this.convertIntent(intent);
if (await this.hasResult(operation)) return this.restore(operation);
else return this.runOperation(operation, ...args);
} else {
await intent.run(...args);
return null;
}
}
}
module.exports = Cache; |
import React, { Component } from 'react';
import DataParser from '../../src/DataParser';
// import MultiCheckbox from '../components/MultiCheckbox';
import ParseInput from '../components/ParseInput';
import DefaultValidator from '../../src/validators/DefaultValidator';
import BooleanParserModule from '../../src/modules/BooleanParserModule';
import NumberParserModule from '../../src/modules/NumberParserModule';
import EmailParserModule from '../../src/modules/EmailParserModule';
import UriParserModule from '../../src/modules/UriParserModule';
const moduleTypes = [
{
label: 'Default',
value: DefaultValidator,
selected: true,
},
{
label: 'Boolean',
value: BooleanParserModule,
selected: true,
},
{
label: 'Number',
value: NumberParserModule,
selected: true,
},
{
label: 'Email',
value: EmailParserModule,
selected: true,
},
{
label: 'URI',
value: UriParserModule,
selected: true,
},
];
export default class DataParserTest extends Component {
constructor() {
super();
const modules = moduleTypes.filter(type => type.selected).map(type => type.value);
this.state = {
parser: null,
stats: {},
modules,
};
window.setTimeout(() => {
this.createParser(modules);
}, 0);
}
onModulesChange(modules) {
this.createParser(modules);
this.setState({ modules });
}
createParser(modules) {
const startTime = new Date().getTime();
const parser = new DataParser(null, modules);
const create = new Date().getTime() - startTime;
this.setState({
parser,
stats: {
create,
},
});
}
render() {
const { parser } = this.state;
return (
<div>
{/*
<div className="row">
<div className="col col-xs-12">
<h3>Supported types</h3>
<MultiCheckbox options={moduleTypes} onChange={value => this.onModulesChange(value)} value={modules} />
</div>
</div>
*/}
<div className="row">
<div className="col col-xs-12">
<ParseInput parser={parser} />
</div>
</div>
</div>
);
}
}
|
/// <reference path="../../../Graphics/ImageSource.ts" />
/// <reference path="../../IMapLoader.ts" />
/// <reference path="../../IMapLoadedResult.ts" />
/// <reference path="../../IMapPreloadInfo.ts" />
/// <reference path="../../IHookFunction.ts" />
/// <reference path="../../../Graphics/TileMaps/SquareTileMap.ts" />
/// <reference path="../../../Graphics/TileMaps/ITileDetails.ts" />
/// <reference path="../../../Assets/TimeSpan.ts" />
/// <reference path="../../../Extensions/Helpers.ts" />
/// <reference path="../../../Utilities/EventHandler1.ts" />
/// <reference path="ITMX.ts" />
/// <reference path="ITMXTileset.ts" />
var EndGate;
(function (EndGate) {
(function (MapLoaders) {
(function (_) {
(function (TMX) {
var OrthogonalLoader = (function () {
function OrthogonalLoader() {
}
OrthogonalLoader.prototype.Load = function (data, propertyHooks, onComplete) {
var _this = this;
// We're initially at 0%.
var percent = 0, tileCount = 0, onPartialLoad = new EndGate.EventHandler1();
// Load all the sources referenced within the data
this.LoadTilesetSources(data.tilesets, function (tileset) {
percent += (1 / data.tilesets.length) * OrthogonalLoader._imagePercentMax;
onPartialLoad.Trigger(percent);
}, function (tilesetSources) {
// Triggered once all the sources have completed loading
// All the tiles extracted represent our resource list
var resources = _this.ExtractTilesetTiles(data.tilesets, tilesetSources, propertyHooks), mappings, layers = new Array(), layerPercentValue = (1 - OrthogonalLoader._imagePercentMax) / data.layers.length;
percent = OrthogonalLoader._imagePercentMax;
asyncLoop(function (next, i) {
if (data.layers[i].type !== "tilelayer") {
throw new Error("Invalid layer type. The layer type '" + data.layers[i].type + "' is not supported.");
}
_this.AsyncBuildLayer(data, i, propertyHooks, resources, function (details, percentLoaded) {
onPartialLoad.Trigger(percent + percentLoaded * layerPercentValue);
}, function (layer) {
percent += layerPercentValue;
onPartialLoad.Trigger(percent);
layers.push(layer);
next();
});
}, data.layers.length, function () {
// All layers loaded
onComplete({
Layers: layers
});
});
});
for (var i = 0; i < data.layers.length; i++) {
tileCount += data.layers[i].data.length;
}
return {
TileCount: tileCount,
LayerCount: data.layers.length,
ResourceSheetCount: data.tilesets.length,
OnPercentLoaded: onPartialLoad
};
};
OrthogonalLoader.prototype.LoadTilesetSources = function (tilesets, onTilesetLoad, onComplete) {
var tilesetSources = {}, loadedCount = 0, onLoaded = function (source) {
onTilesetLoad(source);
// If everything has loaded
if (++loadedCount === tilesets.length) {
onComplete(tilesetSources);
}
};
for (var i = 0; i < tilesets.length; i++) {
tilesetSources[tilesets[i].name] = new EndGate.Graphics.ImageSource(tilesets[i].image, tilesets[i].imagewidth, tilesets[i].imageheight);
tilesetSources[tilesets[i].name].OnLoaded.Bind(onLoaded);
}
};
OrthogonalLoader.prototype.ExtractTilesetTiles = function (tilesets, tilesetSources, propertyHooks) {
var tilesetTiles = new Array(), resourceHooks = new Array(), sources, index;
tilesets.sort(function (a, b) {
return a.firstgid - b.firstgid;
});
for (var i = 0; i < tilesets.length; i++) {
sources = EndGate.Graphics.SquareTileMap.ExtractTiles(tilesetSources[tilesets[i].name], tilesets[i].tilewidth, tilesets[i].tileheight);
for (var property in tilesets[i].properties) {
if (typeof propertyHooks.ResourceSheetHooks[property] !== "undefined") {
for (var j = tilesets[i].firstgid - 1; j < tilesets[i].firstgid - 1 + sources.length; j++) {
if (typeof resourceHooks[j] === "undefined") {
resourceHooks[j] = new Array();
}
resourceHooks[j].push(this.BuildHookerFunction(tilesets[i].properties[property], propertyHooks.ResourceSheetHooks[property]));
}
}
}
for (var tileIndex in tilesets[i].tileproperties) {
for (var property in tilesets[i].tileproperties[tileIndex])
if (typeof propertyHooks.ResourceTileHooks[property] !== "undefined") {
index = parseInt(tileIndex) + tilesets[i].firstgid - 1;
if (typeof resourceHooks[index] === "undefined") {
resourceHooks[index] = new Array();
}
resourceHooks[index].push(this.BuildHookerFunction(tilesets[i].tileproperties[tileIndex][property], propertyHooks.ResourceTileHooks[property]));
}
}
tilesetTiles = tilesetTiles.concat(sources);
}
return {
Resources: tilesetTiles,
ResourceHooks: resourceHooks
};
};
// Not true async but it frees up the DOM
OrthogonalLoader.prototype.AsyncBuildLayer = function (tmxData, layerIndex, propertyHooks, resources, onTileLoad, onComplete) {
var _this = this;
setTimeout(function () {
// Convert the layer data to a 2 dimensional array and subtract 1 from all the data points (to make it 0 based)
var tmxLayer = tmxData.layers[layerIndex], mappings = _this.NormalizeLayerData(tmxLayer.data, tmxData.width), layer = new EndGate.Graphics.SquareTileMap(tmxLayer.x, tmxLayer.y, tmxData.tilewidth, tmxData.tileheight, resources.Resources, mappings), layerHooks = new Array();
for (var property in tmxLayer.properties) {
if (typeof propertyHooks.LayerHooks[property] !== "undefined") {
layerHooks.push(_this.BuildHookerFunction(tmxLayer.properties[property], propertyHooks.LayerHooks[property]));
}
}
layer.ZIndex = layerIndex;
layer.Visible = tmxLayer.visible;
layer.Opacity = tmxLayer.opacity;
// Enough delay to ensure that the page doesn't freeze
layer.RowLoadDelay = EndGate.TimeSpan.FromMilliseconds(5);
layer.OnTileLoad.Bind(function (details, percentComplete) {
if (resources.ResourceHooks[details.ResourceIndex]) {
for (var i = 0; i < resources.ResourceHooks[details.ResourceIndex].length; i++) {
resources.ResourceHooks[details.ResourceIndex][i](details);
}
}
for (var i = 0; i < layerHooks.length; i++) {
layerHooks[i](details);
}
onTileLoad(details, percentComplete);
});
layer.OnLoaded.Bind(function () {
onComplete(layer);
});
}, 0);
};
OrthogonalLoader.prototype.BuildHookerFunction = function (propertyValue, fn) {
return function (details) {
return fn(details, propertyValue);
};
};
OrthogonalLoader.prototype.NormalizeLayerData = function (data, columns) {
var normalized = new Array(), index;
for (var i = 0; i < data.length; i++) {
index = Math.floor(i / columns);
if (!(normalized[index] instanceof Array)) {
normalized[index] = new Array();
}
// Subtract 1 because TMX format starts at 1
normalized[index].push(data[i] - 1);
}
return normalized;
};
OrthogonalLoader._imagePercentMax = .2;
return OrthogonalLoader;
})();
TMX.OrthogonalLoader = OrthogonalLoader;
})(_.TMX || (_.TMX = {}));
var TMX = _.TMX;
})(MapLoaders._ || (MapLoaders._ = {}));
var _ = MapLoaders._;
})(EndGate.MapLoaders || (EndGate.MapLoaders = {}));
var MapLoaders = EndGate.MapLoaders;
})(EndGate || (EndGate = {}));
|
/*
* Copyright 2011-2012 the original author or authors.
*
* 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.
*/
if (typeof __vertxload === 'string') {
throw "Use require() to load Vert.x API modules";
}
var Buffer = require('vertx/buffer');
var parseTools = require('vertx/parse_tools');
/**
* <p>
* There are several objects in vert.x that allow data to be read from and
* written to in the form of Buffers. In Vert.x, calls to write data return
* immediately and writes are internally queued.
* </p>
*
* <p>
* It's not hard to see that if you write to an object faster than it can
* actually write the data to its underlying resource then the write queue
* could grow without bound - eventually resulting in exhausting available
* memory.
* </p>
*
* <p>
* To solve this problem a simple flow control capability is provided by some
* objects in the vert.x API.
* </p>
*
* <p>
* Any flow control aware object that can be written to is said to implement
* {@linkcode module:vertx/streams~WriteStream}, and any flow control object
* that can be read from is said to implement {@linkcode module:vertx/streams~ReadStream}.
* </p>
*
* <p>
* The object types defined in this module are typically not instantiated
* by directly, but are provided to callback functions in modules such as
* {@linkcode module:vertx/file_system}, {@linkcode module:vertx/net} and
* {@linkcode module:vertx/http}.
* </p>
*
* @module vertx/streams
*/
/**
* The {@linkcode module:vertx/streams~ReadStream} interface delegates most
* function calls to the Java class provided by Vert.x
*
* @see https://github.com/eclipse/vert.x/blob/master/vertx-core/src/main/java/org/vertx/java/core/streams/ReadStream.java
*/
/**
* The {@linkcode module:vertx/streams~WriteStream} interface delegates most
* function calls to the Java class provided by Vert.x
*
* @see https://github.com/eclipse/vert.x/blob/master/vertx-core/src/main/java/org/vertx/java/core/streams/WriteStream.java
*
*/
/**
* Provides methods for querying and draining data streams.
* This is used internally and exposed through {@linkcode module:vertx/streams~WriteStream}
* and other mixins and is not typically used directly.
* @param {external:org.vertx.java.core.streams.WriteStream} delegate The Java delegate
* @class
*/
var DrainSupport = function(delegate) {
/**
* Set the maximum size of the write queue to <code>maxSize</code>. You
* will still be able to write to the stream even if there is more than
* <code>maxSize</code> bytes in the write queue. This is used as an
* indicator by classes such as <code>Pump</code> to provide flow control.
* @param {number} size the size of the write queue
*/
this.writeQueueMaxSize = function(size) {
delegate.setWriteQueueMaxSize(size);
return this;
};
/**
* This will return <code>true</code> if there are more bytes in the write
* queue than the value set using <code>writeQueueMaxSize</code>
*/
this.writeQueueFull = function() {
return delegate.writeQueueFull();
};
/**
* Set a drain handler on the stream. If the write queue is full, then the
* handler will be called when the write queue has been reduced to maxSize/2.
* See {@linkcode module:vertx/pump~Pump} for an example of this being used.
* @param {Handler} handler the handler to call when the stream has been drained
*/
this.drainHandler = function(handler) {
delegate.drainHandler(handler);
return this;
};
/**
* Set an exception handler on the stream
* @param {Handler} handler the handler to call when an exception occurs
*/
this.exceptionHandler = function(handler) {
delegate.exceptionHandler(handler);
return this;
};
};
/**
* Provides methods to read from a data stream. It's used by things
* like {@linkcode module:vertx/file_system.AsyncFile} and {@linkcode
* module:vertx/http.HttpServerResponse} and is not typically instantiated
* directly.
*
* @param {external:WriteStream} delegate The Java delegate
* @augments module:vertx/streams~DrainSupport
* @class
*/
var WriteStream = function(delegate) {
/**
* Write some data to the stream. The data is put on an internal write
* queue, and the write actually happens asynchronously. To avoid running
* out of memory by putting too much on the write queue, check the
* {@link module:vertx/streams~WriteStream#writeQueueFull} method before
* writing. This is done automatically if using a {@linkcode module:vertx/pump~Pump}.
*
* @param {module:vertx/buffer~Buffer} data the data to write
*/
this.write = function(data) {
if (data instanceof Buffer) {
delegate.write(data._to_java_buffer());
} else {
delegate.write(data);
}
return this;
};
DrainSupport.call(this, delegate);
/**
* @private
*/
this._delegate = function() { return delegate; };
};
/**
* Provides methods to read from a data stream. This is used internally and
* exposed through {@linkcode module:vertx/streams~ReadStream} and other mixins
* and is not typically used directly.
*
* @param {external:ReadStream} delegate The Java delegate
* @class
*/
var ReadSupport = function(delegate) {
/**
* Set a data handler. As data is read, the handler will be called with
* a Buffer containing the data read.
* @param {BodyHandler} handler the handler to call
*/
this.dataHandler = function(handler) {
delegate.dataHandler(function(buf) {
handler.call(handler, new Buffer(buf));
});
return this;
};
/**
* Pause the <code>ReadStream</code>. While the stream is paused, no data
* will be sent to the data Handler
*/
this.pause = function() {
delegate.pause();
return this;
};
/**
* Resume reading. If the <code>ReadStream</code> has been paused, reading
* will recommence on it.
*/
this.resume = function() {
delegate.resume();
return this;
};
/**
* Set an exception handler.
* @param {Handler} handler the handler to call
*/
this.exceptionHandler = function(handler) {
delegate.exceptionHandler(handler);
return this;
};
};
/**
* Provides methods to read from a data stream. It's used by things
* like {@linkcode module:vertx/file_system.AsyncFile} and {@linkcode
* module:vertx/http.HttpServerResponse} and is not typically instantiated
* directly.
*
* @param {external:ReadStream} delegate The Java delegate
* @augments module:vertx/streams~ReadSupport
* @class
*/
var ReadStream = function(delegate) {
/**
* Set an end handler. Once the stream has ended, and there is no more data
* to be read, the handler will be called.
* @param {Handler} handler the handler to call
*/
this.endHandler = function(handler) {
delegate.endHandler(handler);
return this;
};
ReadSupport.call(this, delegate);
/**
* @private
*/
this._delegate = function() { return delegate; };
};
module.exports.ReadSupport = ReadSupport;
module.exports.ReadStream = ReadStream;
module.exports.DrainSupport = DrainSupport;
module.exports.WriteStream = WriteStream;
|
import assert from 'assert'
import twkb from '../src/twkb'
import { POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, COLLECTION } from '../src/constants'
describe('twkb', function () {
describe('toGeoJSON', function () {
it('should decode point to geojson', function () {
var g = twkb.toGeoJSON(Buffer.from('01000204', 'hex'))
assert.deepEqual(g, {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
geometry: {
type: 'Point',
coordinates: [1, 2]
}
}
]
})
})
it('should decode linestring to geojson', function () {
var g = twkb.toGeoJSON(Buffer.from('02000202020808', 'hex'))
assert.deepEqual(g, {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
geometry: {
type: 'LineString',
coordinates: [[1, 1], [5, 5]]
}
}
]
})
})
it('should decode polygon to geojson', function () {
var g = twkb.toGeoJSON(Buffer.from('03031b000400040205000004000004030000030500000002020000010100', 'hex'))
assert.deepEqual(g, {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
geometry: {
type: 'Polygon',
coordinates: [[[0, 0], [2, 0], [2, 2], [0, 2], [0, 0]], [[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]]
}
}
]
})
})
it('should decode multigeom with ids to geojson', function () {
var g = twkb.toGeoJSON(Buffer.from('04070b0004020402000200020404', 'hex'))
assert.deepEqual(g, {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
id: 0,
geometry: {
type: 'Point',
coordinates: [0, 1]
}
},
{
type: 'Feature',
id: 1,
geometry: {
type: 'Point',
coordinates: [2, 3]
}
}
]
})
})
it('should decode collection to geojson', function () {
var g = twkb.toGeoJSON(Buffer.from('070402000201000002020002080a0404', 'hex'))
assert.deepEqual(g, {
type: 'FeatureCollection',
features: [
{
type: 'Feature',
id: 0,
geometry: {
type: 'Point',
coordinates: [0, 1]
}
},
{
type: 'Feature',
id: 1,
geometry: {
type: 'LineString',
coordinates: [[4, 5], [6, 7]]
}
}
]
})
})
it('should read multiple features', function () {
var g = twkb.toGeoJSON(Buffer.from('0200020202080802000202020808', 'hex'))
assert.equal(g.features.length, 2)
})
})
describe('read', function () {
it('should decode linestring', function () {
// select encode(ST_AsTWKB('LINESTRING(1 1,5 5)'::geometry), 'hex')
var f = twkb.read(Buffer.from('02000202020808', 'hex'))[0]
assert.equal(f.type, LINESTRING)
assert(!f.ndims)
assert(!f.bbox)
var coords = f.coordinates
// assert.equal(f.size, undefined)
assert.equal(coords[0], 1)
assert.equal(coords[1], 1)
assert.equal(coords[2], 5)
assert.equal(coords[3], 5)
})
it('should decode linestring with bbox', function () {
// select encode(ST_AsTWKB('LINESTRING(1 1,5 5)'::geometry, 0, 0, 0, true, true), 'hex') ;
var f = twkb.read(Buffer.from('020309020802080202020808', 'hex'))[0]
assert.equal(f.type, LINESTRING)
assert(!f.ndims)
assert.deepEqual(f.bbox, [1, 1, 5, 5])
var coords = f.coordinates
assert.equal(coords[0], 1)
assert.equal(coords[1], 1)
assert.equal(coords[2], 5)
assert.equal(coords[3], 5)
})
it('should decode multilinestring with bbox', function () {
// select encode(ST_AsTWKB('MULTILINESTRING((1 1,5 5), (1 2, 3 4))'::geometry, 0, 0, 0, true, true), 'hex')
var f = twkb.read(Buffer.from('05030f020802080202020208080207050404', 'hex'))[0]
assert.equal(f.type, MULTILINESTRING)
assert(!f.ndims)
assert.deepEqual(f.bbox, [1, 1, 5, 5])
assert.equal(f.geoms.length, 2)
/*
assert.deepEqual(f.bbox.min, [1, 1])
assert.deepEqual(f.bbox.max, [5, 5])
assert.equal(f.coordinates[0], 1)
assert.equal(f.coordinates[1], 1)
assert.equal(f.coordinates[2], 5)
assert.equal(f.coordinates[3], 5)
*/
})
it('should decode a point', function () {
// select encode(ST_AsTWKB('POINT(1 2)'::geometry), 'hex')
var f = twkb.read(Buffer.from('01000204', 'hex'))[0]
assert.equal(f.type, POINT)
assert(!f.ndims)
assert.equal(f.coordinates[0], 1)
assert.equal(f.coordinates[1], 2)
})
it('should decode a polygon with holes', function () {
// select encode(ST_AsTWKB('POLYGON((0 0,2 0,2 2, 0 2, 0 0), (0 0, 0 1, 1 1, 1 0, 0 0))'::geometry, 0, 0, 0, true, true), 'hex')
var f = twkb.read(Buffer.from('03031b000400040205000004000004030000030500000002020000010100', 'hex'))[0]
assert.equal(f.type, POLYGON)
assert(!f.ndims)
})
it('should decode a multigeom with ids', function () {
// select st_astwkb(array_agg(geom::geometry), array_agg(id)) from (select 0 as id, 'POINT(0 1)' as geom union all select 1 as id, 'POINT(2 3)'as geom) a;
var f = twkb.read(Buffer.from('04070b0004020402000200020404', 'hex'))[0]
assert.equal(f.type, MULTIPOINT)
assert(!f.ndims)
assert.deepEqual(f.bbox, [0, 1, 2, 3])
assert.equal(f.geoms.length, 2)
assert.equal(f.ids.length, 2)
/*
assert.deepEqual(f.geoms[0].coordinates[0], 0);
assert.deepEqual(f.geoms[0].coordinates[1], 1);
assert.equal(f.geoms[1].id, 1)
assert.deepEqual(f.geoms[1].coordinates[0], 2);
assert.deepEqual(f.geoms[1].coordinates[1], 3);
*/
})
it('should decode a collection', function () {
// select st_astwkb(array_agg(geom::geometry), array_agg(id)) from (select 0 as id, 'POINT(0 1)' as geom union all select 1 as id, 'LINESTRING(4 5, 6 7)' as geom) a;
var f = twkb.read(Buffer.from('070402000201000002020002080a0404', 'hex'))[0]
assert.equal(f.type, COLLECTION)
assert.equal(f.geoms.length, 2)
assert.equal(f.geoms[0].type, POINT)
assert.equal(f.geoms[1].type, LINESTRING)
})
})
})
|
/**
* 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/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/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/Cartesian2',[
'./Check',
'./defaultValue',
'./defined',
'./DeveloperError',
'./freezeObject',
'./Math'
], function(
Check,
defaultValue,
defined,
DeveloperError,
freezeObject,
CesiumMath) {
'use strict';
/**
* A 2D Cartesian point.
* @alias Cartesian2
* @constructor
*
* @param {Number} [x=0.0] The X component.
* @param {Number} [y=0.0] The Y component.
*
* @see Cartesian3
* @see Cartesian4
* @see Packable
*/
function Cartesian2(x, y) {
/**
* 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);
}
/**
* Creates a Cartesian2 instance from x and y coordinates.
*
* @param {Number} x The x coordinate.
* @param {Number} y The y coordinate.
* @param {Cartesian2} [result] The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
*/
Cartesian2.fromElements = function(x, y, result) {
if (!defined(result)) {
return new Cartesian2(x, y);
}
result.x = x;
result.y = y;
return result;
};
/**
* Duplicates a Cartesian2 instance.
*
* @param {Cartesian2} cartesian The Cartesian to duplicate.
* @param {Cartesian2} [result] The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided. (Returns undefined if cartesian is undefined)
*/
Cartesian2.clone = function(cartesian, result) {
if (!defined(cartesian)) {
return undefined;
}
if (!defined(result)) {
return new Cartesian2(cartesian.x, cartesian.y);
}
result.x = cartesian.x;
result.y = cartesian.y;
return result;
};
/**
* Creates a Cartesian2 instance from an existing Cartesian3. This simply takes the
* x and y properties of the Cartesian3 and drops z.
* @function
*
* @param {Cartesian3} cartesian The Cartesian3 instance to create a Cartesian2 instance from.
* @param {Cartesian2} [result] The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
*/
Cartesian2.fromCartesian3 = Cartesian2.clone;
/**
* Creates a Cartesian2 instance from an existing Cartesian4. This simply takes the
* x and y properties of the Cartesian4 and drops z and w.
* @function
*
* @param {Cartesian4} cartesian The Cartesian4 instance to create a Cartesian2 instance from.
* @param {Cartesian2} [result] The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
*/
Cartesian2.fromCartesian4 = Cartesian2.clone;
/**
* The number of elements used to pack the object into an array.
* @type {Number}
*/
Cartesian2.packedLength = 2;
/**
* Stores the provided instance into the provided array.
*
* @param {Cartesian2} 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
*/
Cartesian2.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;
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 {Cartesian2} [result] The object into which to store the result.
* @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
*/
Cartesian2.unpack = function(array, startingIndex, result) {
Check.defined('array', array);
startingIndex = defaultValue(startingIndex, 0);
if (!defined(result)) {
result = new Cartesian2();
}
result.x = array[startingIndex++];
result.y = array[startingIndex];
return result;
};
/**
* Flattens an array of Cartesian2s into and array of components.
*
* @param {Cartesian2[]} array The array of cartesians to pack.
* @param {Number[]} result The array onto which to store the result.
* @returns {Number[]} The packed array.
*/
Cartesian2.packArray = function(array, result) {
Check.defined('array', array);
var length = array.length;
if (!defined(result)) {
result = new Array(length * 2);
} else {
result.length = length * 2;
}
for (var i = 0; i < length; ++i) {
Cartesian2.pack(array[i], result, i * 2);
}
return result;
};
/**
* Unpacks an array of cartesian components into and array of Cartesian2s.
*
* @param {Number[]} array The array of components to unpack.
* @param {Cartesian2[]} result The array onto which to store the result.
* @returns {Cartesian2[]} The unpacked array.
*/
Cartesian2.unpackArray = function(array, result) {
Check.defined('array', array);
var length = array.length;
if (!defined(result)) {
result = new Array(length / 2);
} else {
result.length = length / 2;
}
for (var i = 0; i < length; i += 2) {
var index = i / 2;
result[index] = Cartesian2.unpack(array, i, result[index]);
}
return result;
};
/**
* Creates a Cartesian2 from two consecutive elements in an array.
* @function
*
* @param {Number[]} array The array whose two consecutive elements correspond to the x and y components, respectively.
* @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to the x component.
* @param {Cartesian2} [result] The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
*
* @example
* // Create a Cartesian2 with (1.0, 2.0)
* var v = [1.0, 2.0];
* var p = Cesium.Cartesian2.fromArray(v);
*
* // Create a Cartesian2 with (1.0, 2.0) using an offset into an array
* var v2 = [0.0, 0.0, 1.0, 2.0];
* var p2 = Cesium.Cartesian2.fromArray(v2, 2);
*/
Cartesian2.fromArray = Cartesian2.unpack;
/**
* Computes the value of the maximum component for the supplied Cartesian.
*
* @param {Cartesian2} cartesian The cartesian to use.
* @returns {Number} The value of the maximum component.
*/
Cartesian2.maximumComponent = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return Math.max(cartesian.x, cartesian.y);
};
/**
* Computes the value of the minimum component for the supplied Cartesian.
*
* @param {Cartesian2} cartesian The cartesian to use.
* @returns {Number} The value of the minimum component.
*/
Cartesian2.minimumComponent = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return Math.min(cartesian.x, cartesian.y);
};
/**
* Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
*
* @param {Cartesian2} first A cartesian to compare.
* @param {Cartesian2} second A cartesian to compare.
* @param {Cartesian2} result The object into which to store the result.
* @returns {Cartesian2} A cartesian with the minimum components.
*/
Cartesian2.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);
return result;
};
/**
* Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
*
* @param {Cartesian2} first A cartesian to compare.
* @param {Cartesian2} second A cartesian to compare.
* @param {Cartesian2} result The object into which to store the result.
* @returns {Cartesian2} A cartesian with the maximum components.
*/
Cartesian2.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);
return result;
};
/**
* Computes the provided Cartesian's squared magnitude.
*
* @param {Cartesian2} cartesian The Cartesian instance whose squared magnitude is to be computed.
* @returns {Number} The squared magnitude.
*/
Cartesian2.magnitudeSquared = function(cartesian) {
Check.typeOf.object('cartesian', cartesian);
return cartesian.x * cartesian.x + cartesian.y * cartesian.y;
};
/**
* Computes the Cartesian's magnitude (length).
*
* @param {Cartesian2} cartesian The Cartesian instance whose magnitude is to be computed.
* @returns {Number} The magnitude.
*/
Cartesian2.magnitude = function(cartesian) {
return Math.sqrt(Cartesian2.magnitudeSquared(cartesian));
};
var distanceScratch = new Cartesian2();
/**
* Computes the distance between two points.
*
* @param {Cartesian2} left The first point to compute the distance from.
* @param {Cartesian2} right The second point to compute the distance to.
* @returns {Number} The distance between two points.
*
* @example
* // Returns 1.0
* var d = Cesium.Cartesian2.distance(new Cesium.Cartesian2(1.0, 0.0), new Cesium.Cartesian2(2.0, 0.0));
*/
Cartesian2.distance = function(left, right) {
if (!defined(left) || !defined(right)) {
throw new DeveloperError('left and right are required.');
}
Cartesian2.subtract(left, right, distanceScratch);
return Cartesian2.magnitude(distanceScratch);
};
/**
* Computes the squared distance between two points. Comparing squared distances
* using this function is more efficient than comparing distances using {@link Cartesian2#distance}.
*
* @param {Cartesian2} left The first point to compute the distance from.
* @param {Cartesian2} 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.Cartesian2.distance(new Cesium.Cartesian2(1.0, 0.0), new Cesium.Cartesian2(3.0, 0.0));
*/
Cartesian2.distanceSquared = function(left, right) {
if (!defined(left) || !defined(right)) {
throw new DeveloperError('left and right are required.');
}
Cartesian2.subtract(left, right, distanceScratch);
return Cartesian2.magnitudeSquared(distanceScratch);
};
/**
* Computes the normalized form of the supplied Cartesian.
*
* @param {Cartesian2} cartesian The Cartesian to be normalized.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.normalize = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var magnitude = Cartesian2.magnitude(cartesian);
result.x = cartesian.x / magnitude;
result.y = cartesian.y / magnitude;
if (isNaN(result.x) || isNaN(result.y)) {
throw new DeveloperError('normalized result is not a number');
}
return result;
};
/**
* Computes the dot (scalar) product of two Cartesians.
*
* @param {Cartesian2} left The first Cartesian.
* @param {Cartesian2} right The second Cartesian.
* @returns {Number} The dot product.
*/
Cartesian2.dot = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
return left.x * right.x + left.y * right.y;
};
/**
* Computes the componentwise product of two Cartesians.
*
* @param {Cartesian2} left The first Cartesian.
* @param {Cartesian2} right The second Cartesian.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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;
return result;
};
/**
* Computes the componentwise quotient of two Cartesians.
*
* @param {Cartesian2} left The first Cartesian.
* @param {Cartesian2} right The second Cartesian.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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;
return result;
};
/**
* Computes the componentwise sum of two Cartesians.
*
* @param {Cartesian2} left The first Cartesian.
* @param {Cartesian2} right The second Cartesian.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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;
return result;
};
/**
* Computes the componentwise difference of two Cartesians.
*
* @param {Cartesian2} left The first Cartesian.
* @param {Cartesian2} right The second Cartesian.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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;
return result;
};
/**
* Multiplies the provided Cartesian componentwise by the provided scalar.
*
* @param {Cartesian2} cartesian The Cartesian to be scaled.
* @param {Number} scalar The scalar to multiply with.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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;
return result;
};
/**
* Divides the provided Cartesian componentwise by the provided scalar.
*
* @param {Cartesian2} cartesian The Cartesian to be divided.
* @param {Number} scalar The scalar to divide by.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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;
return result;
};
/**
* Negates the provided Cartesian.
*
* @param {Cartesian2} cartesian The Cartesian to be negated.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.negate = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
result.x = -cartesian.x;
result.y = -cartesian.y;
return result;
};
/**
* Computes the absolute value of the provided Cartesian.
*
* @param {Cartesian2} cartesian The Cartesian whose absolute value is to be computed.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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);
return result;
};
var lerpScratch = new Cartesian2();
/**
* Computes the linear interpolation or extrapolation at t using the provided cartesians.
*
* @param {Cartesian2} start The value corresponding to t at 0.0.
* @param {Cartesian2} end The value corresponding to t at 1.0.
* @param {Number} t The point along t at which to interpolate.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter.
*/
Cartesian2.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);
Cartesian2.multiplyByScalar(end, t, lerpScratch);
result = Cartesian2.multiplyByScalar(start, 1.0 - t, result);
return Cartesian2.add(lerpScratch, result, result);
};
var angleBetweenScratch = new Cartesian2();
var angleBetweenScratch2 = new Cartesian2();
/**
* Returns the angle, in radians, between the provided Cartesians.
*
* @param {Cartesian2} left The first Cartesian.
* @param {Cartesian2} right The second Cartesian.
* @returns {Number} The angle between the Cartesians.
*/
Cartesian2.angleBetween = function(left, right) {
Check.typeOf.object('left', left);
Check.typeOf.object('right', right);
Cartesian2.normalize(left, angleBetweenScratch);
Cartesian2.normalize(right, angleBetweenScratch2);
return CesiumMath.acosClamped(Cartesian2.dot(angleBetweenScratch, angleBetweenScratch2));
};
var mostOrthogonalAxisScratch = new Cartesian2();
/**
* Returns the axis that is most orthogonal to the provided Cartesian.
*
* @param {Cartesian2} cartesian The Cartesian on which to find the most orthogonal axis.
* @param {Cartesian2} result The object onto which to store the result.
* @returns {Cartesian2} The most orthogonal axis.
*/
Cartesian2.mostOrthogonalAxis = function(cartesian, result) {
Check.typeOf.object('cartesian', cartesian);
Check.typeOf.object('result', result);
var f = Cartesian2.normalize(cartesian, mostOrthogonalAxisScratch);
Cartesian2.abs(f, f);
if (f.x <= f.y) {
result = Cartesian2.clone(Cartesian2.UNIT_X, result);
} else {
result = Cartesian2.clone(Cartesian2.UNIT_Y, result);
}
return result;
};
/**
* Compares the provided Cartesians componentwise and returns
* <code>true</code> if they are equal, <code>false</code> otherwise.
*
* @param {Cartesian2} [left] The first Cartesian.
* @param {Cartesian2} [right] The second Cartesian.
* @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
*/
Cartesian2.equals = function(left, right) {
return (left === right) ||
((defined(left)) &&
(defined(right)) &&
(left.x === right.x) &&
(left.y === right.y));
};
/**
* @private
*/
Cartesian2.equalsArray = function(cartesian, array, offset) {
return cartesian.x === array[offset] &&
cartesian.y === array[offset + 1];
};
/**
* Compares the provided Cartesians componentwise and returns
* <code>true</code> if they pass an absolute or relative tolerance test,
* <code>false</code> otherwise.
*
* @param {Cartesian2} [left] The first Cartesian.
* @param {Cartesian2} [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.
*/
Cartesian2.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));
};
/**
* An immutable Cartesian2 instance initialized to (0.0, 0.0).
*
* @type {Cartesian2}
* @constant
*/
Cartesian2.ZERO = freezeObject(new Cartesian2(0.0, 0.0));
/**
* An immutable Cartesian2 instance initialized to (1.0, 0.0).
*
* @type {Cartesian2}
* @constant
*/
Cartesian2.UNIT_X = freezeObject(new Cartesian2(1.0, 0.0));
/**
* An immutable Cartesian2 instance initialized to (0.0, 1.0).
*
* @type {Cartesian2}
* @constant
*/
Cartesian2.UNIT_Y = freezeObject(new Cartesian2(0.0, 1.0));
/**
* Duplicates this Cartesian2 instance.
*
* @param {Cartesian2} [result] The object onto which to store the result.
* @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
*/
Cartesian2.prototype.clone = function(result) {
return Cartesian2.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 {Cartesian2} [right] The right hand side Cartesian.
* @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
*/
Cartesian2.prototype.equals = function(right) {
return Cartesian2.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 {Cartesian2} [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.
*/
Cartesian2.prototype.equalsEpsilon = function(right, relativeEpsilon, absoluteEpsilon) {
return Cartesian2.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)'.
*/
Cartesian2.prototype.toString = function() {
return '(' + this.x + ', ' + this.y + ')';
};
return Cartesian2;
});
/*global define*/
define('Core/AttributeCompression',[
'./Cartesian2',
'./Cartesian3',
'./defined',
'./DeveloperError',
'./Math'
], function(
Cartesian2,
Cartesian3,
defined,
DeveloperError,
CesiumMath) {
'use strict';
/**
* Attribute compression and decompression functions.
*
* @exports AttributeCompression
*
* @private
*/
var AttributeCompression = {};
/**
* Encodes a normalized vector into 2 SNORM values in the range of [0-rangeMax] following the 'oct' encoding.
*
* Oct encoding is a compact representation of unit length vectors.
* The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
* Cigolle et al 2014: {@link http://jcgt.org/published/0003/02/01/}
*
* @param {Cartesian3} vector The normalized vector to be compressed into 2 component 'oct' encoding.
* @param {Cartesian2} result The 2 component oct-encoded unit length vector.
* @param {Number} rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.
* @returns {Cartesian2} The 2 component oct-encoded unit length vector.
*
* @exception {DeveloperError} vector must be normalized.
*
* @see AttributeCompression.octDecodeInRange
*/
AttributeCompression.octEncodeInRange = function(vector, rangeMax, result) {
if (!defined(vector)) {
throw new DeveloperError('vector is required.');
}
if (!defined(result)) {
throw new DeveloperError('result is required.');
}
var magSquared = Cartesian3.magnitudeSquared(vector);
if (Math.abs(magSquared - 1.0) > CesiumMath.EPSILON6) {
throw new DeveloperError('vector must be normalized.');
}
result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
if (vector.z < 0) {
var x = result.x;
var y = result.y;
result.x = (1.0 - Math.abs(y)) * CesiumMath.signNotZero(x);
result.y = (1.0 - Math.abs(x)) * CesiumMath.signNotZero(y);
}
result.x = CesiumMath.toSNorm(result.x, rangeMax);
result.y = CesiumMath.toSNorm(result.y, rangeMax);
return result;
};
/**
* Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding.
*
* @param {Cartesian3} vector The normalized vector to be compressed into 2 byte 'oct' encoding.
* @param {Cartesian2} result The 2 byte oct-encoded unit length vector.
* @returns {Cartesian2} The 2 byte oct-encoded unit length vector.
*
* @exception {DeveloperError} vector must be normalized.
*
* @see AttributeCompression.octEncodeInRange
* @see AttributeCompression.octDecode
*/
AttributeCompression.octEncode = function(vector, result) {
return AttributeCompression.octEncodeInRange(vector, 255, result);
};
/**
* Decodes a unit-length vector in 'oct' encoding to a normalized 3-component vector.
*
* @param {Number} x The x component of the oct-encoded unit length vector.
* @param {Number} y The y component of the oct-encoded unit length vector.
* @param {Number} rangeMax The maximum value of the SNORM range. The encoded vector is stored in log2(rangeMax+1) bits.
* @param {Cartesian3} result The decoded and normalized vector
* @returns {Cartesian3} The decoded and normalized vector.
*
* @exception {DeveloperError} x and y must be an unsigned normalized integer between 0 and rangeMax.
*
* @see AttributeCompression.octEncodeInRange
*/
AttributeCompression.octDecodeInRange = function(x, y, rangeMax, result) {
if (!defined(result)) {
throw new DeveloperError('result is required.');
}
if (x < 0 || x > rangeMax || y < 0 || y > rangeMax) {
throw new DeveloperError('x and y must be a signed normalized integer between 0 and ' + rangeMax);
}
result.x = CesiumMath.fromSNorm(x, rangeMax);
result.y = CesiumMath.fromSNorm(y, rangeMax);
result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));
if (result.z < 0.0)
{
var oldVX = result.x;
result.x = (1.0 - Math.abs(result.y)) * CesiumMath.signNotZero(oldVX);
result.y = (1.0 - Math.abs(oldVX)) * CesiumMath.signNotZero(result.y);
}
return Cartesian3.normalize(result, result);
};
/**
* Decodes a unit-length vector in 2 byte 'oct' encoding to a normalized 3-component vector.
*
* @param {Number} x The x component of the oct-encoded unit length vector.
* @param {Number} y The y component of the oct-encoded unit length vector.
* @param {Cartesian3} result The decoded and normalized vector.
* @returns {Cartesian3} The decoded and normalized vector.
*
* @exception {DeveloperError} x and y must be an unsigned normalized integer between 0 and 255.
*
* @see AttributeCompression.octDecodeInRange
*/
AttributeCompression.octDecode = function(x, y, result) {
return AttributeCompression.octDecodeInRange(x, y, 255, result);
};
/**
* Packs an oct encoded vector into a single floating-point number.
*
* @param {Cartesian2} encoded The oct encoded vector.
* @returns {Number} The oct encoded vector packed into a single float.
*
*/
AttributeCompression.octPackFloat = function(encoded) {
if (!defined(encoded)) {
throw new DeveloperError('encoded is required.');
}
return 256.0 * encoded.x + encoded.y;
};
var scratchEncodeCart2 = new Cartesian2();
/**
* Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding and
* stores those values in a single float-point number.
*
* @param {Cartesian3} vector The normalized vector to be compressed into 2 byte 'oct' encoding.
* @returns {Number} The 2 byte oct-encoded unit length vector.
*
* @exception {DeveloperError} vector must be normalized.
*/
AttributeCompression.octEncodeFloat = function(vector) {
AttributeCompression.octEncode(vector, scratchEncodeCart2);
return AttributeCompression.octPackFloat(scratchEncodeCart2);
};
/**
* Decodes a unit-length vector in 'oct' encoding packed in a floating-point number to a normalized 3-component vector.
*
* @param {Number} value The oct-encoded unit length vector stored as a single floating-point number.
* @param {Cartesian3} result The decoded and normalized vector
* @returns {Cartesian3} The decoded and normalized vector.
*
*/
AttributeCompression.octDecodeFloat = function(value, result) {
if (!defined(value)) {
throw new DeveloperError('value is required.');
}
var temp = value / 256.0;
var x = Math.floor(temp);
var y = (temp - x) * 256.0;
return AttributeCompression.octDecode(x, y, result);
};
/**
* Encodes three normalized vectors into 6 SNORM values in the range of [0-255] following the 'oct' encoding and
* packs those into two floating-point numbers.
*
* @param {Cartesian3} v1 A normalized vector to be compressed.
* @param {Cartesian3} v2 A normalized vector to be compressed.
* @param {Cartesian3} v3 A normalized vector to be compressed.
* @param {Cartesian2} result The 'oct' encoded vectors packed into two floating-point numbers.
* @returns {Cartesian2} The 'oct' encoded vectors packed into two floating-point numbers.
*
*/
AttributeCompression.octPack = function(v1, v2, v3, result) {
if (!defined(v1)) {
throw new DeveloperError('v1 is required.');
}
if (!defined(v2)) {
throw new DeveloperError('v2 is required.');
}
if (!defined(v3)) {
throw new DeveloperError('v3 is required.');
}
if (!defined(result)) {
throw new DeveloperError('result is required.');
}
var encoded1 = AttributeCompression.octEncodeFloat(v1);
var encoded2 = AttributeCompression.octEncodeFloat(v2);
var encoded3 = AttributeCompression.octEncode(v3, scratchEncodeCart2);
result.x = 65536.0 * encoded3.x + encoded1;
result.y = 65536.0 * encoded3.y + encoded2;
return result;
};
/**
* Decodes three unit-length vectors in 'oct' encoding packed into a floating-point number to a normalized 3-component vector.
*
* @param {Cartesian2} packed The three oct-encoded unit length vectors stored as two floating-point number.
* @param {Cartesian3} v1 One decoded and normalized vector.
* @param {Cartesian3} v2 One decoded and normalized vector.
* @param {Cartesian3} v3 One decoded and normalized vector.
*/
AttributeCompression.octUnpack = function(packed, v1, v2, v3) {
if (!defined(packed)) {
throw new DeveloperError('packed is required.');
}
if (!defined(v1)) {
throw new DeveloperError('v1 is required.');
}
if (!defined(v2)) {
throw new DeveloperError('v2 is required.');
}
if (!defined(v3)) {
throw new DeveloperError('v3 is required.');
}
var temp = packed.x / 65536.0;
var x = Math.floor(temp);
var encodedFloat1 = (temp - x) * 65536.0;
temp = packed.y / 65536.0;
var y = Math.floor(temp);
var encodedFloat2 = (temp - y) * 65536.0;
AttributeCompression.octDecodeFloat(encodedFloat1, v1);
AttributeCompression.octDecodeFloat(encodedFloat2, v2);
AttributeCompression.octDecode(x, y, v3);
};
/**
* Pack texture coordinates into a single float. The texture coordinates will only preserve 12 bits of precision.
*
* @param {Cartesian2} textureCoordinates The texture coordinates to compress. Both coordinates must be in the range 0.0-1.0.
* @returns {Number} The packed texture coordinates.
*
*/
AttributeCompression.compressTextureCoordinates = function(textureCoordinates) {
if (!defined(textureCoordinates)) {
throw new DeveloperError('textureCoordinates is required.');
}
// Move x and y to the range 0-4095;
var x = (textureCoordinates.x * 4095.0) | 0;
var y = (textureCoordinates.y * 4095.0) | 0;
return 4096.0 * x + y;
};
/**
* Decompresses texture coordinates that were packed into a single float.
*
* @param {Number} compressed The compressed texture coordinates.
* @param {Cartesian2} result The decompressed texture coordinates.
* @returns {Cartesian2} The modified result parameter.
*
*/
AttributeCompression.decompressTextureCoordinates = function(compressed, result) {
if (!defined(compressed)) {
throw new DeveloperError('compressed is required.');
}
if (!defined(result)) {
throw new DeveloperError('result is required.');
}
var temp = compressed / 4096.0;
var xZeroTo4095 = Math.floor(temp);
result.x = xZeroTo4095 / 4095.0;
result.y = (compressed - xZeroTo4095 * 4096) / 4095;
return result;
};
return AttributeCompression;
});
/*global define*/
define('Core/barycentricCoordinates',[
'./Cartesian2',
'./Cartesian3',
'./defined',
'./DeveloperError'
], function(
Cartesian2,
Cartesian3,
defined,
DeveloperError) {
'use strict';
var scratchCartesian1 = new Cartesian3();
var scratchCartesian2 = new Cartesian3();
var scratchCartesian3 = new Cartesian3();
/**
* Computes the barycentric coordinates for a point with respect to a triangle.
*
* @exports barycentricCoordinates
*
* @param {Cartesian2|Cartesian3} point The point to test.
* @param {Cartesian2|Cartesian3} p0 The first point of the triangle, corresponding to the barycentric x-axis.
* @param {Cartesian2|Cartesian3} p1 The second point of the triangle, corresponding to the barycentric y-axis.
* @param {Cartesian2|Cartesian3} p2 The third point of the triangle, corresponding to the barycentric z-axis.
* @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
* // Returns Cartesian3.UNIT_X
* var p = new Cesium.Cartesian3(-1.0, 0.0, 0.0);
* var b = Cesium.barycentricCoordinates(p,
* new Cesium.Cartesian3(-1.0, 0.0, 0.0),
* new Cesium.Cartesian3( 1.0, 0.0, 0.0),
* new Cesium.Cartesian3( 0.0, 1.0, 1.0));
*/
function barycentricCoordinates(point, p0, p1, p2, result) {
if (!defined(point) || !defined(p0) || !defined(p1) || !defined(p2)) {
throw new DeveloperError('point, p0, p1, and p2 are required.');
}
if (!defined(result)) {
result = new Cartesian3();
}
// Implementation based on http://www.blackpawn.com/texts/pointinpoly/default.html.
var v0, v1, v2;
var dot00, dot01, dot02, dot11, dot12;
if(!defined(p0.z)) {
v0 = Cartesian2.subtract(p1, p0, scratchCartesian1);
v1 = Cartesian2.subtract(p2, p0, scratchCartesian2);
v2 = Cartesian2.subtract(point, p0, scratchCartesian3);
dot00 = Cartesian2.dot(v0, v0);
dot01 = Cartesian2.dot(v0, v1);
dot02 = Cartesian2.dot(v0, v2);
dot11 = Cartesian2.dot(v1, v1);
dot12 = Cartesian2.dot(v1, v2);
} else {
v0 = Cartesian3.subtract(p1, p0, scratchCartesian1);
v1 = Cartesian3.subtract(p2, p0, scratchCartesian2);
v2 = Cartesian3.subtract(point, p0, scratchCartesian3);
dot00 = Cartesian3.dot(v0, v0);
dot01 = Cartesian3.dot(v0, v1);
dot02 = Cartesian3.dot(v0, v2);
dot11 = Cartesian3.dot(v1, v1);
dot12 = Cartesian3.dot(v1, v2);
}
var q = 1.0 / (dot00 * dot11 - dot01 * dot01);
result.y = (dot11 * dot02 - dot01 * dot12) * q;
result.z = (dot00 * dot12 - dot01 * dot02) * q;
result.x = 1.0 - result.y - result.z;
return result;
}
return barycentricCoordinates;
});
/*global define*/
define('Core/EncodedCartesian3',[
'./Cartesian3',
'./defined',
'./DeveloperError'
], function(
Cartesian3,
defined,
DeveloperError) {
'use strict';
/**
* A fixed-point encoding of a {@link Cartesian3} with 64-bit floating-point components, as two {@link Cartesian3}
* values that, when converted to 32-bit floating-point and added, approximate the original input.
* <p>
* This is used to encode positions in vertex buffers for rendering without jittering artifacts
* as described in {@link http://blogs.agi.com/insight3d/index.php/2008/09/03/precisions-precisions/|Precisions, Precisions}.
* </p>
*
* @alias EncodedCartesian3
* @constructor
*
* @private
*/
function EncodedCartesian3() {
/**
* The high bits for each component. Bits 0 to 22 store the whole value. Bits 23 to 31 are not used.
*
* @type {Cartesian3}
* @default {@link Cartesian3.ZERO}
*/
this.high = Cartesian3.clone(Cartesian3.ZERO);
/**
* The low bits for each component. Bits 7 to 22 store the whole value, and bits 0 to 6 store the fraction. Bits 23 to 31 are not used.
*
* @type {Cartesian3}
* @default {@link Cartesian3.ZERO}
*/
this.low = Cartesian3.clone(Cartesian3.ZERO);
}
/**
* Encodes a 64-bit floating-point value as two floating-point values that, when converted to
* 32-bit floating-point and added, approximate the original input. The returned object
* has <code>high</code> and <code>low</code> properties for the high and low bits, respectively.
* <p>
* The fixed-point encoding follows {@link http://blogs.agi.com/insight3d/index.php/2008/09/03/precisions-precisions/|Precisions, Precisions}.
* </p>
*
* @param {Number} value The floating-point value to encode.
* @param {Object} [result] The object onto which to store the result.
* @returns {Object} The modified result parameter or a new instance if one was not provided.
*
* @example
* var value = 1234567.1234567;
* var splitValue = Cesium.EncodedCartesian3.encode(value);
*/
EncodedCartesian3.encode = function(value, result) {
if (!defined(value)) {
throw new DeveloperError('value is required');
}
if (!defined(result)) {
result = {
high : 0.0,
low : 0.0
};
}
var doubleHigh;
if (value >= 0.0) {
doubleHigh = Math.floor(value / 65536.0) * 65536.0;
result.high = doubleHigh;
result.low = value - doubleHigh;
} else {
doubleHigh = Math.floor(-value / 65536.0) * 65536.0;
result.high = -doubleHigh;
result.low = value + doubleHigh;
}
return result;
};
var scratchEncode = {
high : 0.0,
low : 0.0
};
/**
* Encodes a {@link Cartesian3} with 64-bit floating-point components as two {@link Cartesian3}
* values that, when converted to 32-bit floating-point and added, approximate the original input.
* <p>
* The fixed-point encoding follows {@link http://blogs.agi.com/insight3d/index.php/2008/09/03/precisions-precisions/|Precisions, Precisions}.
* </p>
*
* @param {Cartesian3} cartesian The cartesian to encode.
* @param {EncodedCartesian3} [result] The object onto which to store the result.
* @returns {EncodedCartesian3} The modified result parameter or a new EncodedCartesian3 instance if one was not provided.
*
* @example
* var cart = new Cesium.Cartesian3(-10000000.0, 0.0, 10000000.0);
* var encoded = Cesium.EncodedCartesian3.fromCartesian(cart);
*/
EncodedCartesian3.fromCartesian = function(cartesian, result) {
if (!defined(cartesian)) {
throw new DeveloperError('cartesian is required');
}
if (!defined(result)) {
result = new EncodedCartesian3();
}
var high = result.high;
var low = result.low;
EncodedCartesian3.encode(cartesian.x, scratchEncode);
high.x = scratchEncode.high;
low.x = scratchEncode.low;
EncodedCartesian3.encode(cartesian.y, scratchEncode);
high.y = scratchEncode.high;
low.y = scratchEncode.low;
EncodedCartesian3.encode(cartesian.z, scratchEncode);
high.z = scratchEncode.high;
low.z = scratchEncode.low;
return result;
};
var encodedP = new EncodedCartesian3();
/**
* Encodes the provided <code>cartesian</code>, and writes it to an array with <code>high</code>
* components followed by <code>low</code> components, i.e. <code>[high.x, high.y, high.z, low.x, low.y, low.z]</code>.
* <p>
* This is used to create interleaved high-precision position vertex attributes.
* </p>
*
* @param {Cartesian3} cartesian The cartesian to encode.
* @param {Number[]} cartesianArray The array to write to.
* @param {Number} index The index into the array to start writing. Six elements will be written.
*
* @exception {DeveloperError} index must be a number greater than or equal to 0.
*
* @example
* var positions = [
* new Cesium.Cartesian3(),
* // ...
* ];
* var encodedPositions = new Float32Array(2 * 3 * positions.length);
* var j = 0;
* for (var i = 0; i < positions.length; ++i) {
* Cesium.EncodedCartesian3.writeElement(positions[i], encodedPositions, j);
* j += 6;
* }
*/
EncodedCartesian3.writeElements = function(cartesian, cartesianArray, index) {
if (!defined(cartesian)) {
throw new DeveloperError('cartesian is required');
}
if (!defined(cartesianArray)) {
throw new DeveloperError('cartesianArray is required');
}
if (typeof index !== 'number' || index < 0) {
throw new DeveloperError('index must be a number greater than or equal to 0.');
}
EncodedCartesian3.fromCartesian(cartesian, encodedP);
var high = encodedP.high;
var low = encodedP.low;
cartesianArray[index] = high.x;
cartesianArray[index + 1] = high.y;
cartesianArray[index + 2] = high.z;
cartesianArray[index + 3] = low.x;
cartesianArray[index + 4] = low.y;
cartesianArray[index + 5] = low.z;
};
return EncodedCartesian3;
});
/*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/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/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/Tipsify',[
'./defaultValue',
'./defined',
'./DeveloperError'
], function(
defaultValue,
defined,
DeveloperError) {
'use strict';
/**
* Encapsulates an algorithm to optimize triangles for the post
* vertex-shader cache. This is based on the 2007 SIGGRAPH paper
* 'Fast Triangle Reordering for Vertex Locality and Reduced Overdraw.'
* The runtime is linear but several passes are made.
*
* @exports Tipsify
*
* @see <a href='http://gfx.cs.princeton.edu/pubs/Sander_2007_%3ETR/tipsy.pdf'>
* Fast Triangle Reordering for Vertex Locality and Reduced Overdraw</a>
* by Sander, Nehab, and Barczak
*
* @private
*/
var Tipsify = {};
/**
* Calculates the average cache miss ratio (ACMR) for a given set of indices.
*
* @param {Object} options Object with the following properties:
* @param {Number[]} options.indices Lists triads of numbers corresponding to the indices of the vertices
* in the vertex buffer that define the geometry's triangles.
* @param {Number} [options.maximumIndex] The maximum value of the elements in <code>args.indices</code>.
* If not supplied, this value will be computed.
* @param {Number} [options.cacheSize=24] The number of vertices that can be stored in the cache at any one time.
* @returns {Number} The average cache miss ratio (ACMR).
*
* @exception {DeveloperError} indices length must be a multiple of three.
* @exception {DeveloperError} cacheSize must be greater than two.
*
* @example
* var indices = [0, 1, 2, 3, 4, 5];
* var maxIndex = 5;
* var cacheSize = 3;
* var acmr = Cesium.Tipsify.calculateACMR({indices : indices, maxIndex : maxIndex, cacheSize : cacheSize});
*/
Tipsify.calculateACMR = function(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var indices = options.indices;
var maximumIndex = options.maximumIndex;
var cacheSize = defaultValue(options.cacheSize, 24);
if (!defined(indices)) {
throw new DeveloperError('indices is required.');
}
var numIndices = indices.length;
if (numIndices < 3 || numIndices % 3 !== 0) {
throw new DeveloperError('indices length must be a multiple of three.');
}
if (maximumIndex <= 0) {
throw new DeveloperError('maximumIndex must be greater than zero.');
}
if (cacheSize < 3) {
throw new DeveloperError('cacheSize must be greater than two.');
}
// Compute the maximumIndex if not given
if (!defined(maximumIndex)) {
maximumIndex = 0;
var currentIndex = 0;
var intoIndices = indices[currentIndex];
while (currentIndex < numIndices) {
if (intoIndices > maximumIndex) {
maximumIndex = intoIndices;
}
++currentIndex;
intoIndices = indices[currentIndex];
}
}
// Vertex time stamps
var vertexTimeStamps = [];
for ( var i = 0; i < maximumIndex + 1; i++) {
vertexTimeStamps[i] = 0;
}
// Cache processing
var s = cacheSize + 1;
for ( var j = 0; j < numIndices; ++j) {
if ((s - vertexTimeStamps[indices[j]]) > cacheSize) {
vertexTimeStamps[indices[j]] = s;
++s;
}
}
return (s - cacheSize + 1) / (numIndices / 3);
};
/**
* Optimizes triangles for the post-vertex shader cache.
*
* @param {Number[]} options.indices Lists triads of numbers corresponding to the indices of the vertices
* in the vertex buffer that define the geometry's triangles.
* @param {Number} [options.maximumIndex] The maximum value of the elements in <code>args.indices</code>.
* If not supplied, this value will be computed.
* @param {Number} [options.cacheSize=24] The number of vertices that can be stored in the cache at any one time.
* @returns {Number[]} A list of the input indices in an optimized order.
*
* @exception {DeveloperError} indices length must be a multiple of three.
* @exception {DeveloperError} cacheSize must be greater than two.
*
* @example
* var indices = [0, 1, 2, 3, 4, 5];
* var maxIndex = 5;
* var cacheSize = 3;
* var reorderedIndices = Cesium.Tipsify.tipsify({indices : indices, maxIndex : maxIndex, cacheSize : cacheSize});
*/
Tipsify.tipsify = function(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
var indices = options.indices;
var maximumIndex = options.maximumIndex;
var cacheSize = defaultValue(options.cacheSize, 24);
var cursor;
function skipDeadEnd(vertices, deadEnd, indices, maximumIndexPlusOne) {
while (deadEnd.length >= 1) {
// while the stack is not empty
var d = deadEnd[deadEnd.length - 1]; // top of the stack
deadEnd.splice(deadEnd.length - 1, 1); // pop the stack
if (vertices[d].numLiveTriangles > 0) {
return d;
}
}
while (cursor < maximumIndexPlusOne) {
if (vertices[cursor].numLiveTriangles > 0) {
++cursor;
return cursor - 1;
}
++cursor;
}
return -1;
}
function getNextVertex(indices, cacheSize, oneRing, vertices, s, deadEnd, maximumIndexPlusOne) {
var n = -1;
var p;
var m = -1;
var itOneRing = 0;
while (itOneRing < oneRing.length) {
var index = oneRing[itOneRing];
if (vertices[index].numLiveTriangles) {
p = 0;
if ((s - vertices[index].timeStamp + (2 * vertices[index].numLiveTriangles)) <= cacheSize) {
p = s - vertices[index].timeStamp;
}
if ((p > m) || (m === -1)) {
m = p;
n = index;
}
}
++itOneRing;
}
if (n === -1) {
return skipDeadEnd(vertices, deadEnd, indices, maximumIndexPlusOne);
}
return n;
}
if (!defined(indices)) {
throw new DeveloperError('indices is required.');
}
var numIndices = indices.length;
if (numIndices < 3 || numIndices % 3 !== 0) {
throw new DeveloperError('indices length must be a multiple of three.');
}
if (maximumIndex <= 0) {
throw new DeveloperError('maximumIndex must be greater than zero.');
}
if (cacheSize < 3) {
throw new DeveloperError('cacheSize must be greater than two.');
}
// Determine maximum index
var maximumIndexPlusOne = 0;
var currentIndex = 0;
var intoIndices = indices[currentIndex];
var endIndex = numIndices;
if (defined(maximumIndex)) {
maximumIndexPlusOne = maximumIndex + 1;
} else {
while (currentIndex < endIndex) {
if (intoIndices > maximumIndexPlusOne) {
maximumIndexPlusOne = intoIndices;
}
++currentIndex;
intoIndices = indices[currentIndex];
}
if (maximumIndexPlusOne === -1) {
return 0;
}
++maximumIndexPlusOne;
}
// Vertices
var vertices = [];
for ( var i = 0; i < maximumIndexPlusOne; i++) {
vertices[i] = {
numLiveTriangles : 0,
timeStamp : 0,
vertexTriangles : []
};
}
currentIndex = 0;
var triangle = 0;
while (currentIndex < endIndex) {
vertices[indices[currentIndex]].vertexTriangles.push(triangle);
++(vertices[indices[currentIndex]]).numLiveTriangles;
vertices[indices[currentIndex + 1]].vertexTriangles.push(triangle);
++(vertices[indices[currentIndex + 1]]).numLiveTriangles;
vertices[indices[currentIndex + 2]].vertexTriangles.push(triangle);
++(vertices[indices[currentIndex + 2]]).numLiveTriangles;
++triangle;
currentIndex += 3;
}
// Starting index
var f = 0;
// Time Stamp
var s = cacheSize + 1;
cursor = 1;
// Process
var oneRing = [];
var deadEnd = []; //Stack
var vertex;
var intoVertices;
var currentOutputIndex = 0;
var outputIndices = [];
var numTriangles = numIndices / 3;
var triangleEmitted = [];
for (i = 0; i < numTriangles; i++) {
triangleEmitted[i] = false;
}
var index;
var limit;
while (f !== -1) {
oneRing = [];
intoVertices = vertices[f];
limit = intoVertices.vertexTriangles.length;
for ( var k = 0; k < limit; ++k) {
triangle = intoVertices.vertexTriangles[k];
if (!triangleEmitted[triangle]) {
triangleEmitted[triangle] = true;
currentIndex = triangle + triangle + triangle;
for ( var j = 0; j < 3; ++j) {
// Set this index as a possible next index
index = indices[currentIndex];
oneRing.push(index);
deadEnd.push(index);
// Output index
outputIndices[currentOutputIndex] = index;
++currentOutputIndex;
// Cache processing
vertex = vertices[index];
--vertex.numLiveTriangles;
if ((s - vertex.timeStamp) > cacheSize) {
vertex.timeStamp = s;
++s;
}
++currentIndex;
}
}
}
f = getNextVertex(indices, cacheSize, oneRing, vertices, s, deadEnd, maximumIndexPlusOne);
}
return outputIndices;
};
return Tipsify;
});
/*global define*/
define('Core/GeometryPipeline',[
'./AttributeCompression',
'./barycentricCoordinates',
'./BoundingSphere',
'./Cartesian2',
'./Cartesian3',
'./Cartesian4',
'./Cartographic',
'./ComponentDatatype',
'./defaultValue',
'./defined',
'./DeveloperError',
'./EncodedCartesian3',
'./GeographicProjection',
'./Geometry',
'./GeometryAttribute',
'./GeometryType',
'./IndexDatatype',
'./Intersect',
'./IntersectionTests',
'./Math',
'./Matrix3',
'./Matrix4',
'./Plane',
'./PrimitiveType',
'./Tipsify'
], function(
AttributeCompression,
barycentricCoordinates,
BoundingSphere,
Cartesian2,
Cartesian3,
Cartesian4,
Cartographic,
ComponentDatatype,
defaultValue,
defined,
DeveloperError,
EncodedCartesian3,
GeographicProjection,
Geometry,
GeometryAttribute,
GeometryType,
IndexDatatype,
Intersect,
IntersectionTests,
CesiumMath,
Matrix3,
Matrix4,
Plane,
PrimitiveType,
Tipsify) {
'use strict';
/**
* Content pipeline functions for geometries.
*
* @exports GeometryPipeline
*
* @see Geometry
*/
var GeometryPipeline = {};
function addTriangle(lines, index, i0, i1, i2) {
lines[index++] = i0;
lines[index++] = i1;
lines[index++] = i1;
lines[index++] = i2;
lines[index++] = i2;
lines[index] = i0;
}
function trianglesToLines(triangles) {
var count = triangles.length;
var size = (count / 3) * 6;
var lines = IndexDatatype.createTypedArray(count, size);
var index = 0;
for ( var i = 0; i < count; i += 3, index += 6) {
addTriangle(lines, index, triangles[i], triangles[i + 1], triangles[i + 2]);
}
return lines;
}
function triangleStripToLines(triangles) {
var count = triangles.length;
if (count >= 3) {
var size = (count - 2) * 6;
var lines = IndexDatatype.createTypedArray(count, size);
addTriangle(lines, 0, triangles[0], triangles[1], triangles[2]);
var index = 6;
for ( var i = 3; i < count; ++i, index += 6) {
addTriangle(lines, index, triangles[i - 1], triangles[i], triangles[i - 2]);
}
return lines;
}
return new Uint16Array();
}
function triangleFanToLines(triangles) {
if (triangles.length > 0) {
var count = triangles.length - 1;
var size = (count - 1) * 6;
var lines = IndexDatatype.createTypedArray(count, size);
var base = triangles[0];
var index = 0;
for ( var i = 1; i < count; ++i, index += 6) {
addTriangle(lines, index, base, triangles[i], triangles[i + 1]);
}
return lines;
}
return new Uint16Array();
}
/**
* Converts a geometry's triangle indices to line indices. If the geometry has an <code>indices</code>
* and its <code>primitiveType</code> is <code>TRIANGLES</code>, <code>TRIANGLE_STRIP</code>,
* <code>TRIANGLE_FAN</code>, it is converted to <code>LINES</code>; otherwise, the geometry is not changed.
* <p>
* This is commonly used to create a wireframe geometry for visual debugging.
* </p>
*
* @param {Geometry} geometry The geometry to modify.
* @returns {Geometry} The modified <code>geometry</code> argument, with its triangle indices converted to lines.
*
* @exception {DeveloperError} geometry.primitiveType must be TRIANGLES, TRIANGLE_STRIP, or TRIANGLE_FAN.
*
* @example
* geometry = Cesium.GeometryPipeline.toWireframe(geometry);
*/
GeometryPipeline.toWireframe = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
var indices = geometry.indices;
if (defined(indices)) {
switch (geometry.primitiveType) {
case PrimitiveType.TRIANGLES:
geometry.indices = trianglesToLines(indices);
break;
case PrimitiveType.TRIANGLE_STRIP:
geometry.indices = triangleStripToLines(indices);
break;
case PrimitiveType.TRIANGLE_FAN:
geometry.indices = triangleFanToLines(indices);
break;
default:
throw new DeveloperError('geometry.primitiveType must be TRIANGLES, TRIANGLE_STRIP, or TRIANGLE_FAN.');
}
geometry.primitiveType = PrimitiveType.LINES;
}
return geometry;
};
/**
* Creates a new {@link Geometry} with <code>LINES</code> representing the provided
* attribute (<code>attributeName</code>) for the provided geometry. This is used to
* visualize vector attributes like normals, tangents, and bitangents.
*
* @param {Geometry} geometry The <code>Geometry</code> instance with the attribute.
* @param {String} [attributeName='normal'] The name of the attribute.
* @param {Number} [length=10000.0] The length of each line segment in meters. This can be negative to point the vector in the opposite direction.
* @returns {Geometry} A new <code>Geometry</code> instance with line segments for the vector.
*
* @exception {DeveloperError} geometry.attributes must have an attribute with the same name as the attributeName parameter.
*
* @example
* var geometry = Cesium.GeometryPipeline.createLineSegmentsForVectors(instance.geometry, 'bitangent', 100000.0);
*/
GeometryPipeline.createLineSegmentsForVectors = function(geometry, attributeName, length) {
attributeName = defaultValue(attributeName, 'normal');
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
if (!defined(geometry.attributes.position)) {
throw new DeveloperError('geometry.attributes.position is required.');
}
if (!defined(geometry.attributes[attributeName])) {
throw new DeveloperError('geometry.attributes must have an attribute with the same name as the attributeName parameter, ' + attributeName + '.');
}
length = defaultValue(length, 10000.0);
var positions = geometry.attributes.position.values;
var vectors = geometry.attributes[attributeName].values;
var positionsLength = positions.length;
var newPositions = new Float64Array(2 * positionsLength);
var j = 0;
for (var i = 0; i < positionsLength; i += 3) {
newPositions[j++] = positions[i];
newPositions[j++] = positions[i + 1];
newPositions[j++] = positions[i + 2];
newPositions[j++] = positions[i] + (vectors[i] * length);
newPositions[j++] = positions[i + 1] + (vectors[i + 1] * length);
newPositions[j++] = positions[i + 2] + (vectors[i + 2] * length);
}
var newBoundingSphere;
var bs = geometry.boundingSphere;
if (defined(bs)) {
newBoundingSphere = new BoundingSphere(bs.center, bs.radius + length);
}
return new Geometry({
attributes : {
position : new GeometryAttribute({
componentDatatype : ComponentDatatype.DOUBLE,
componentsPerAttribute : 3,
values : newPositions
})
},
primitiveType : PrimitiveType.LINES,
boundingSphere : newBoundingSphere
});
};
/**
* Creates an object that maps attribute names to unique locations (indices)
* for matching vertex attributes and shader programs.
*
* @param {Geometry} geometry The geometry, which is not modified, to create the object for.
* @returns {Object} An object with attribute name / index pairs.
*
* @example
* var attributeLocations = Cesium.GeometryPipeline.createAttributeLocations(geometry);
* // Example output
* // {
* // 'position' : 0,
* // 'normal' : 1
* // }
*/
GeometryPipeline.createAttributeLocations = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
// There can be a WebGL performance hit when attribute 0 is disabled, so
// assign attribute locations to well-known attributes.
var semantics = [
'position',
'positionHigh',
'positionLow',
// From VertexFormat.position - after 2D projection and high-precision encoding
'position3DHigh',
'position3DLow',
'position2DHigh',
'position2DLow',
// From Primitive
'pickColor',
// From VertexFormat
'normal',
'st',
'tangent',
'bitangent',
// For shadow volumes
'extrudeDirection',
// From compressing texture coordinates and normals
'compressedAttributes'
];
var attributes = geometry.attributes;
var indices = {};
var j = 0;
var i;
var len = semantics.length;
// Attribute locations for well-known attributes
for (i = 0; i < len; ++i) {
var semantic = semantics[i];
if (defined(attributes[semantic])) {
indices[semantic] = j++;
}
}
// Locations for custom attributes
for (var name in attributes) {
if (attributes.hasOwnProperty(name) && (!defined(indices[name]))) {
indices[name] = j++;
}
}
return indices;
};
/**
* Reorders a geometry's attributes and <code>indices</code> to achieve better performance from the GPU's pre-vertex-shader cache.
*
* @param {Geometry} geometry The geometry to modify.
* @returns {Geometry} The modified <code>geometry</code> argument, with its attributes and indices reordered for the GPU's pre-vertex-shader cache.
*
* @exception {DeveloperError} Each attribute array in geometry.attributes must have the same number of attributes.
*
*
* @example
* geometry = Cesium.GeometryPipeline.reorderForPreVertexCache(geometry);
*
* @see GeometryPipeline.reorderForPostVertexCache
*/
GeometryPipeline.reorderForPreVertexCache = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
var numVertices = Geometry.computeNumberOfVertices(geometry);
var indices = geometry.indices;
if (defined(indices)) {
var indexCrossReferenceOldToNew = new Int32Array(numVertices);
for ( var i = 0; i < numVertices; i++) {
indexCrossReferenceOldToNew[i] = -1;
}
// Construct cross reference and reorder indices
var indicesIn = indices;
var numIndices = indicesIn.length;
var indicesOut = IndexDatatype.createTypedArray(numVertices, numIndices);
var intoIndicesIn = 0;
var intoIndicesOut = 0;
var nextIndex = 0;
var tempIndex;
while (intoIndicesIn < numIndices) {
tempIndex = indexCrossReferenceOldToNew[indicesIn[intoIndicesIn]];
if (tempIndex !== -1) {
indicesOut[intoIndicesOut] = tempIndex;
} else {
tempIndex = indicesIn[intoIndicesIn];
indexCrossReferenceOldToNew[tempIndex] = nextIndex;
indicesOut[intoIndicesOut] = nextIndex;
++nextIndex;
}
++intoIndicesIn;
++intoIndicesOut;
}
geometry.indices = indicesOut;
// Reorder attributes
var attributes = geometry.attributes;
for ( var property in attributes) {
if (attributes.hasOwnProperty(property) &&
defined(attributes[property]) &&
defined(attributes[property].values)) {
var attribute = attributes[property];
var elementsIn = attribute.values;
var intoElementsIn = 0;
var numComponents = attribute.componentsPerAttribute;
var elementsOut = ComponentDatatype.createTypedArray(attribute.componentDatatype, nextIndex * numComponents);
while (intoElementsIn < numVertices) {
var temp = indexCrossReferenceOldToNew[intoElementsIn];
if (temp !== -1) {
for (i = 0; i < numComponents; i++) {
elementsOut[numComponents * temp + i] = elementsIn[numComponents * intoElementsIn + i];
}
}
++intoElementsIn;
}
attribute.values = elementsOut;
}
}
}
return geometry;
};
/**
* Reorders a geometry's <code>indices</code> to achieve better performance from the GPU's
* post vertex-shader cache by using the Tipsify algorithm. If the geometry <code>primitiveType</code>
* is not <code>TRIANGLES</code> or the geometry does not have an <code>indices</code>, this function has no effect.
*
* @param {Geometry} geometry The geometry to modify.
* @param {Number} [cacheCapacity=24] The number of vertices that can be held in the GPU's vertex cache.
* @returns {Geometry} The modified <code>geometry</code> argument, with its indices reordered for the post-vertex-shader cache.
*
* @exception {DeveloperError} cacheCapacity must be greater than two.
*
*
* @example
* geometry = Cesium.GeometryPipeline.reorderForPostVertexCache(geometry);
*
* @see GeometryPipeline.reorderForPreVertexCache
* @see {@link http://gfx.cs.princ0eton.edu/pubs/Sander_2007_%3ETR/tipsy.pdf|Fast Triangle Reordering for Vertex Locality and Reduced Overdraw}
* by Sander, Nehab, and Barczak
*/
GeometryPipeline.reorderForPostVertexCache = function(geometry, cacheCapacity) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
var indices = geometry.indices;
if ((geometry.primitiveType === PrimitiveType.TRIANGLES) && (defined(indices))) {
var numIndices = indices.length;
var maximumIndex = 0;
for ( var j = 0; j < numIndices; j++) {
if (indices[j] > maximumIndex) {
maximumIndex = indices[j];
}
}
geometry.indices = Tipsify.tipsify({
indices : indices,
maximumIndex : maximumIndex,
cacheSize : cacheCapacity
});
}
return geometry;
};
function copyAttributesDescriptions(attributes) {
var newAttributes = {};
for ( var attribute in attributes) {
if (attributes.hasOwnProperty(attribute) &&
defined(attributes[attribute]) &&
defined(attributes[attribute].values)) {
var attr = attributes[attribute];
newAttributes[attribute] = new GeometryAttribute({
componentDatatype : attr.componentDatatype,
componentsPerAttribute : attr.componentsPerAttribute,
normalize : attr.normalize,
values : []
});
}
}
return newAttributes;
}
function copyVertex(destinationAttributes, sourceAttributes, index) {
for ( var attribute in sourceAttributes) {
if (sourceAttributes.hasOwnProperty(attribute) &&
defined(sourceAttributes[attribute]) &&
defined(sourceAttributes[attribute].values)) {
var attr = sourceAttributes[attribute];
for ( var k = 0; k < attr.componentsPerAttribute; ++k) {
destinationAttributes[attribute].values.push(attr.values[(index * attr.componentsPerAttribute) + k]);
}
}
}
}
/**
* Splits a geometry into multiple geometries, if necessary, to ensure that indices in the
* <code>indices</code> fit into unsigned shorts. This is used to meet the WebGL requirements
* when unsigned int indices are not supported.
* <p>
* If the geometry does not have any <code>indices</code>, this function has no effect.
* </p>
*
* @param {Geometry} geometry The geometry to be split into multiple geometries.
* @returns {Geometry[]} An array of geometries, each with indices that fit into unsigned shorts.
*
* @exception {DeveloperError} geometry.primitiveType must equal to PrimitiveType.TRIANGLES, PrimitiveType.LINES, or PrimitiveType.POINTS
* @exception {DeveloperError} All geometry attribute lists must have the same number of attributes.
*
* @example
* var geometries = Cesium.GeometryPipeline.fitToUnsignedShortIndices(geometry);
*/
GeometryPipeline.fitToUnsignedShortIndices = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
if ((defined(geometry.indices)) &&
((geometry.primitiveType !== PrimitiveType.TRIANGLES) &&
(geometry.primitiveType !== PrimitiveType.LINES) &&
(geometry.primitiveType !== PrimitiveType.POINTS))) {
throw new DeveloperError('geometry.primitiveType must equal to PrimitiveType.TRIANGLES, PrimitiveType.LINES, or PrimitiveType.POINTS.');
}
var geometries = [];
// If there's an index list and more than 64K attributes, it is possible that
// some indices are outside the range of unsigned short [0, 64K - 1]
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
if (defined(geometry.indices) && (numberOfVertices >= CesiumMath.SIXTY_FOUR_KILOBYTES)) {
var oldToNewIndex = [];
var newIndices = [];
var currentIndex = 0;
var newAttributes = copyAttributesDescriptions(geometry.attributes);
var originalIndices = geometry.indices;
var numberOfIndices = originalIndices.length;
var indicesPerPrimitive;
if (geometry.primitiveType === PrimitiveType.TRIANGLES) {
indicesPerPrimitive = 3;
} else if (geometry.primitiveType === PrimitiveType.LINES) {
indicesPerPrimitive = 2;
} else if (geometry.primitiveType === PrimitiveType.POINTS) {
indicesPerPrimitive = 1;
}
for ( var j = 0; j < numberOfIndices; j += indicesPerPrimitive) {
for (var k = 0; k < indicesPerPrimitive; ++k) {
var x = originalIndices[j + k];
var i = oldToNewIndex[x];
if (!defined(i)) {
i = currentIndex++;
oldToNewIndex[x] = i;
copyVertex(newAttributes, geometry.attributes, x);
}
newIndices.push(i);
}
if (currentIndex + indicesPerPrimitive >= CesiumMath.SIXTY_FOUR_KILOBYTES) {
geometries.push(new Geometry({
attributes : newAttributes,
indices : newIndices,
primitiveType : geometry.primitiveType,
boundingSphere : geometry.boundingSphere,
boundingSphereCV : geometry.boundingSphereCV
}));
// Reset for next vertex-array
oldToNewIndex = [];
newIndices = [];
currentIndex = 0;
newAttributes = copyAttributesDescriptions(geometry.attributes);
}
}
if (newIndices.length !== 0) {
geometries.push(new Geometry({
attributes : newAttributes,
indices : newIndices,
primitiveType : geometry.primitiveType,
boundingSphere : geometry.boundingSphere,
boundingSphereCV : geometry.boundingSphereCV
}));
}
} else {
// No need to split into multiple geometries
geometries.push(geometry);
}
return geometries;
};
var scratchProjectTo2DCartesian3 = new Cartesian3();
var scratchProjectTo2DCartographic = new Cartographic();
/**
* Projects a geometry's 3D <code>position</code> attribute to 2D, replacing the <code>position</code>
* attribute with separate <code>position3D</code> and <code>position2D</code> attributes.
* <p>
* If the geometry does not have a <code>position</code>, this function has no effect.
* </p>
*
* @param {Geometry} geometry The geometry to modify.
* @param {String} attributeName The name of the attribute.
* @param {String} attributeName3D The name of the attribute in 3D.
* @param {String} attributeName2D The name of the attribute in 2D.
* @param {Object} [projection=new GeographicProjection()] The projection to use.
* @returns {Geometry} The modified <code>geometry</code> argument with <code>position3D</code> and <code>position2D</code> attributes.
*
* @exception {DeveloperError} geometry must have attribute matching the attributeName argument.
* @exception {DeveloperError} The attribute componentDatatype must be ComponentDatatype.DOUBLE.
* @exception {DeveloperError} Could not project a point to 2D.
*
* @example
* geometry = Cesium.GeometryPipeline.projectTo2D(geometry, 'position', 'position3D', 'position2D');
*/
GeometryPipeline.projectTo2D = function(geometry, attributeName, attributeName3D, attributeName2D, projection) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
if (!defined(attributeName)) {
throw new DeveloperError('attributeName is required.');
}
if (!defined(attributeName3D)) {
throw new DeveloperError('attributeName3D is required.');
}
if (!defined(attributeName2D)) {
throw new DeveloperError('attributeName2D is required.');
}
if (!defined(geometry.attributes[attributeName])) {
throw new DeveloperError('geometry must have attribute matching the attributeName argument: ' + attributeName + '.');
}
if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype.DOUBLE) {
throw new DeveloperError('The attribute componentDatatype must be ComponentDatatype.DOUBLE.');
}
var attribute = geometry.attributes[attributeName];
projection = (defined(projection)) ? projection : new GeographicProjection();
var ellipsoid = projection.ellipsoid;
// Project original values to 2D.
var values3D = attribute.values;
var projectedValues = new Float64Array(values3D.length);
var index = 0;
for ( var i = 0; i < values3D.length; i += 3) {
var value = Cartesian3.fromArray(values3D, i, scratchProjectTo2DCartesian3);
var lonLat = ellipsoid.cartesianToCartographic(value, scratchProjectTo2DCartographic);
if (!defined(lonLat)) {
throw new DeveloperError('Could not project point (' + value.x + ', ' + value.y + ', ' + value.z + ') to 2D.');
}
var projectedLonLat = projection.project(lonLat, scratchProjectTo2DCartesian3);
projectedValues[index++] = projectedLonLat.x;
projectedValues[index++] = projectedLonLat.y;
projectedValues[index++] = projectedLonLat.z;
}
// Rename original cartesians to WGS84 cartesians.
geometry.attributes[attributeName3D] = attribute;
// Replace original cartesians with 2D projected cartesians
geometry.attributes[attributeName2D] = new GeometryAttribute({
componentDatatype : ComponentDatatype.DOUBLE,
componentsPerAttribute : 3,
values : projectedValues
});
delete geometry.attributes[attributeName];
return geometry;
};
var encodedResult = {
high : 0.0,
low : 0.0
};
/**
* Encodes floating-point geometry attribute values as two separate attributes to improve
* rendering precision.
* <p>
* This is commonly used to create high-precision position vertex attributes.
* </p>
*
* @param {Geometry} geometry The geometry to modify.
* @param {String} attributeName The name of the attribute.
* @param {String} attributeHighName The name of the attribute for the encoded high bits.
* @param {String} attributeLowName The name of the attribute for the encoded low bits.
* @returns {Geometry} The modified <code>geometry</code> argument, with its encoded attribute.
*
* @exception {DeveloperError} geometry must have attribute matching the attributeName argument.
* @exception {DeveloperError} The attribute componentDatatype must be ComponentDatatype.DOUBLE.
*
* @example
* geometry = Cesium.GeometryPipeline.encodeAttribute(geometry, 'position3D', 'position3DHigh', 'position3DLow');
*/
GeometryPipeline.encodeAttribute = function(geometry, attributeName, attributeHighName, attributeLowName) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
if (!defined(attributeName)) {
throw new DeveloperError('attributeName is required.');
}
if (!defined(attributeHighName)) {
throw new DeveloperError('attributeHighName is required.');
}
if (!defined(attributeLowName)) {
throw new DeveloperError('attributeLowName is required.');
}
if (!defined(geometry.attributes[attributeName])) {
throw new DeveloperError('geometry must have attribute matching the attributeName argument: ' + attributeName + '.');
}
if (geometry.attributes[attributeName].componentDatatype !== ComponentDatatype.DOUBLE) {
throw new DeveloperError('The attribute componentDatatype must be ComponentDatatype.DOUBLE.');
}
var attribute = geometry.attributes[attributeName];
var values = attribute.values;
var length = values.length;
var highValues = new Float32Array(length);
var lowValues = new Float32Array(length);
for (var i = 0; i < length; ++i) {
EncodedCartesian3.encode(values[i], encodedResult);
highValues[i] = encodedResult.high;
lowValues[i] = encodedResult.low;
}
var componentsPerAttribute = attribute.componentsPerAttribute;
geometry.attributes[attributeHighName] = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : componentsPerAttribute,
values : highValues
});
geometry.attributes[attributeLowName] = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : componentsPerAttribute,
values : lowValues
});
delete geometry.attributes[attributeName];
return geometry;
};
var scratchCartesian3 = new Cartesian3();
function transformPoint(matrix, attribute) {
if (defined(attribute)) {
var values = attribute.values;
var length = values.length;
for (var i = 0; i < length; i += 3) {
Cartesian3.unpack(values, i, scratchCartesian3);
Matrix4.multiplyByPoint(matrix, scratchCartesian3, scratchCartesian3);
Cartesian3.pack(scratchCartesian3, values, i);
}
}
}
function transformVector(matrix, attribute) {
if (defined(attribute)) {
var values = attribute.values;
var length = values.length;
for (var i = 0; i < length; i += 3) {
Cartesian3.unpack(values, i, scratchCartesian3);
Matrix3.multiplyByVector(matrix, scratchCartesian3, scratchCartesian3);
scratchCartesian3 = Cartesian3.normalize(scratchCartesian3, scratchCartesian3);
Cartesian3.pack(scratchCartesian3, values, i);
}
}
}
var inverseTranspose = new Matrix4();
var normalMatrix = new Matrix3();
/**
* Transforms a geometry instance to world coordinates. This changes
* the instance's <code>modelMatrix</code> to {@link Matrix4.IDENTITY} and transforms the
* following attributes if they are present: <code>position</code>, <code>normal</code>,
* <code>tangent</code>, and <code>bitangent</code>.
*
* @param {GeometryInstance} instance The geometry instance to modify.
* @returns {GeometryInstance} The modified <code>instance</code> argument, with its attributes transforms to world coordinates.
*
* @example
* Cesium.GeometryPipeline.transformToWorldCoordinates(instance);
*/
GeometryPipeline.transformToWorldCoordinates = function(instance) {
if (!defined(instance)) {
throw new DeveloperError('instance is required.');
}
var modelMatrix = instance.modelMatrix;
if (Matrix4.equals(modelMatrix, Matrix4.IDENTITY)) {
// Already in world coordinates
return instance;
}
var attributes = instance.geometry.attributes;
// Transform attributes in known vertex formats
transformPoint(modelMatrix, attributes.position);
transformPoint(modelMatrix, attributes.prevPosition);
transformPoint(modelMatrix, attributes.nextPosition);
if ((defined(attributes.normal)) ||
(defined(attributes.tangent)) ||
(defined(attributes.bitangent))) {
Matrix4.inverse(modelMatrix, inverseTranspose);
Matrix4.transpose(inverseTranspose, inverseTranspose);
Matrix4.getRotation(inverseTranspose, normalMatrix);
transformVector(normalMatrix, attributes.normal);
transformVector(normalMatrix, attributes.tangent);
transformVector(normalMatrix, attributes.bitangent);
}
var boundingSphere = instance.geometry.boundingSphere;
if (defined(boundingSphere)) {
instance.geometry.boundingSphere = BoundingSphere.transform(boundingSphere, modelMatrix, boundingSphere);
}
instance.modelMatrix = Matrix4.clone(Matrix4.IDENTITY);
return instance;
};
function findAttributesInAllGeometries(instances, propertyName) {
var length = instances.length;
var attributesInAllGeometries = {};
var attributes0 = instances[0][propertyName].attributes;
var name;
for (name in attributes0) {
if (attributes0.hasOwnProperty(name) &&
defined(attributes0[name]) &&
defined(attributes0[name].values)) {
var attribute = attributes0[name];
var numberOfComponents = attribute.values.length;
var inAllGeometries = true;
// Does this same attribute exist in all geometries?
for (var i = 1; i < length; ++i) {
var otherAttribute = instances[i][propertyName].attributes[name];
if ((!defined(otherAttribute)) ||
(attribute.componentDatatype !== otherAttribute.componentDatatype) ||
(attribute.componentsPerAttribute !== otherAttribute.componentsPerAttribute) ||
(attribute.normalize !== otherAttribute.normalize)) {
inAllGeometries = false;
break;
}
numberOfComponents += otherAttribute.values.length;
}
if (inAllGeometries) {
attributesInAllGeometries[name] = new GeometryAttribute({
componentDatatype : attribute.componentDatatype,
componentsPerAttribute : attribute.componentsPerAttribute,
normalize : attribute.normalize,
values : ComponentDatatype.createTypedArray(attribute.componentDatatype, numberOfComponents)
});
}
}
}
return attributesInAllGeometries;
}
var tempScratch = new Cartesian3();
function combineGeometries(instances, propertyName) {
var length = instances.length;
var name;
var i;
var j;
var k;
var m = instances[0].modelMatrix;
var haveIndices = (defined(instances[0][propertyName].indices));
var primitiveType = instances[0][propertyName].primitiveType;
for (i = 1; i < length; ++i) {
if (!Matrix4.equals(instances[i].modelMatrix, m)) {
throw new DeveloperError('All instances must have the same modelMatrix.');
}
if ((defined(instances[i][propertyName].indices)) !== haveIndices) {
throw new DeveloperError('All instance geometries must have an indices or not have one.');
}
if (instances[i][propertyName].primitiveType !== primitiveType) {
throw new DeveloperError('All instance geometries must have the same primitiveType.');
}
}
// Find subset of attributes in all geometries
var attributes = findAttributesInAllGeometries(instances, propertyName);
var values;
var sourceValues;
var sourceValuesLength;
// Combine attributes from each geometry into a single typed array
for (name in attributes) {
if (attributes.hasOwnProperty(name)) {
values = attributes[name].values;
k = 0;
for (i = 0; i < length; ++i) {
sourceValues = instances[i][propertyName].attributes[name].values;
sourceValuesLength = sourceValues.length;
for (j = 0; j < sourceValuesLength; ++j) {
values[k++] = sourceValues[j];
}
}
}
}
// Combine index lists
var indices;
if (haveIndices) {
var numberOfIndices = 0;
for (i = 0; i < length; ++i) {
numberOfIndices += instances[i][propertyName].indices.length;
}
var numberOfVertices = Geometry.computeNumberOfVertices(new Geometry({
attributes : attributes,
primitiveType : PrimitiveType.POINTS
}));
var destIndices = IndexDatatype.createTypedArray(numberOfVertices, numberOfIndices);
var destOffset = 0;
var offset = 0;
for (i = 0; i < length; ++i) {
var sourceIndices = instances[i][propertyName].indices;
var sourceIndicesLen = sourceIndices.length;
for (k = 0; k < sourceIndicesLen; ++k) {
destIndices[destOffset++] = offset + sourceIndices[k];
}
offset += Geometry.computeNumberOfVertices(instances[i][propertyName]);
}
indices = destIndices;
}
// Create bounding sphere that includes all instances
var center = new Cartesian3();
var radius = 0.0;
var bs;
for (i = 0; i < length; ++i) {
bs = instances[i][propertyName].boundingSphere;
if (!defined(bs)) {
// If any geometries have an undefined bounding sphere, then so does the combined geometry
center = undefined;
break;
}
Cartesian3.add(bs.center, center, center);
}
if (defined(center)) {
Cartesian3.divideByScalar(center, length, center);
for (i = 0; i < length; ++i) {
bs = instances[i][propertyName].boundingSphere;
var tempRadius = Cartesian3.magnitude(Cartesian3.subtract(bs.center, center, tempScratch)) + bs.radius;
if (tempRadius > radius) {
radius = tempRadius;
}
}
}
return new Geometry({
attributes : attributes,
indices : indices,
primitiveType : primitiveType,
boundingSphere : (defined(center)) ? new BoundingSphere(center, radius) : undefined
});
}
/**
* Combines geometry from several {@link GeometryInstance} objects into one geometry.
* This concatenates the attributes, concatenates and adjusts the indices, and creates
* a bounding sphere encompassing all instances.
* <p>
* If the instances do not have the same attributes, a subset of attributes common
* to all instances is used, and the others are ignored.
* </p>
* <p>
* This is used by {@link Primitive} to efficiently render a large amount of static data.
* </p>
*
* @private
*
* @param {GeometryInstance[]} [instances] The array of {@link GeometryInstance} objects whose geometry will be combined.
* @returns {Geometry} A single geometry created from the provided geometry instances.
*
* @exception {DeveloperError} All instances must have the same modelMatrix.
* @exception {DeveloperError} All instance geometries must have an indices or not have one.
* @exception {DeveloperError} All instance geometries must have the same primitiveType.
*
*
* @example
* for (var i = 0; i < instances.length; ++i) {
* Cesium.GeometryPipeline.transformToWorldCoordinates(instances[i]);
* }
* var geometries = Cesium.GeometryPipeline.combineInstances(instances);
*
* @see GeometryPipeline.transformToWorldCoordinates
*/
GeometryPipeline.combineInstances = function(instances) {
if ((!defined(instances)) || (instances.length < 1)) {
throw new DeveloperError('instances is required and must have length greater than zero.');
}
var instanceGeometry = [];
var instanceSplitGeometry = [];
var length = instances.length;
for (var i = 0; i < length; ++i) {
var instance = instances[i];
if (defined(instance.geometry)) {
instanceGeometry.push(instance);
} else if (defined(instance.westHemisphereGeometry) && defined(instance.eastHemisphereGeometry)) {
instanceSplitGeometry.push(instance);
}
}
var geometries = [];
if (instanceGeometry.length > 0) {
geometries.push(combineGeometries(instanceGeometry, 'geometry'));
}
if (instanceSplitGeometry.length > 0) {
geometries.push(combineGeometries(instanceSplitGeometry, 'westHemisphereGeometry'));
geometries.push(combineGeometries(instanceSplitGeometry, 'eastHemisphereGeometry'));
}
return geometries;
};
var normal = new Cartesian3();
var v0 = new Cartesian3();
var v1 = new Cartesian3();
var v2 = new Cartesian3();
/**
* Computes per-vertex normals for a geometry containing <code>TRIANGLES</code> by averaging the normals of
* all triangles incident to the vertex. The result is a new <code>normal</code> attribute added to the geometry.
* This assumes a counter-clockwise winding order.
*
* @param {Geometry} geometry The geometry to modify.
* @returns {Geometry} The modified <code>geometry</code> argument with the computed <code>normal</code> attribute.
*
* @exception {DeveloperError} geometry.indices length must be greater than 0 and be a multiple of 3.
* @exception {DeveloperError} geometry.primitiveType must be {@link PrimitiveType.TRIANGLES}.
*
* @example
* Cesium.GeometryPipeline.computeNormal(geometry);
*/
GeometryPipeline.computeNormal = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
if (!defined(geometry.attributes.position) || !defined(geometry.attributes.position.values)) {
throw new DeveloperError('geometry.attributes.position.values is required.');
}
if (!defined(geometry.indices)) {
throw new DeveloperError('geometry.indices is required.');
}
if (geometry.indices.length < 2 || geometry.indices.length % 3 !== 0) {
throw new DeveloperError('geometry.indices length must be greater than 0 and be a multiple of 3.');
}
if (geometry.primitiveType !== PrimitiveType.TRIANGLES) {
throw new DeveloperError('geometry.primitiveType must be PrimitiveType.TRIANGLES.');
}
var indices = geometry.indices;
var attributes = geometry.attributes;
var vertices = attributes.position.values;
var numVertices = attributes.position.values.length / 3;
var numIndices = indices.length;
var normalsPerVertex = new Array(numVertices);
var normalsPerTriangle = new Array(numIndices / 3);
var normalIndices = new Array(numIndices);
for ( var i = 0; i < numVertices; i++) {
normalsPerVertex[i] = {
indexOffset : 0,
count : 0,
currentCount : 0
};
}
var j = 0;
for (i = 0; i < numIndices; i += 3) {
var i0 = indices[i];
var i1 = indices[i + 1];
var i2 = indices[i + 2];
var i03 = i0 * 3;
var i13 = i1 * 3;
var i23 = i2 * 3;
v0.x = vertices[i03];
v0.y = vertices[i03 + 1];
v0.z = vertices[i03 + 2];
v1.x = vertices[i13];
v1.y = vertices[i13 + 1];
v1.z = vertices[i13 + 2];
v2.x = vertices[i23];
v2.y = vertices[i23 + 1];
v2.z = vertices[i23 + 2];
normalsPerVertex[i0].count++;
normalsPerVertex[i1].count++;
normalsPerVertex[i2].count++;
Cartesian3.subtract(v1, v0, v1);
Cartesian3.subtract(v2, v0, v2);
normalsPerTriangle[j] = Cartesian3.cross(v1, v2, new Cartesian3());
j++;
}
var indexOffset = 0;
for (i = 0; i < numVertices; i++) {
normalsPerVertex[i].indexOffset += indexOffset;
indexOffset += normalsPerVertex[i].count;
}
j = 0;
var vertexNormalData;
for (i = 0; i < numIndices; i += 3) {
vertexNormalData = normalsPerVertex[indices[i]];
var index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
normalIndices[index] = j;
vertexNormalData.currentCount++;
vertexNormalData = normalsPerVertex[indices[i + 1]];
index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
normalIndices[index] = j;
vertexNormalData.currentCount++;
vertexNormalData = normalsPerVertex[indices[i + 2]];
index = vertexNormalData.indexOffset + vertexNormalData.currentCount;
normalIndices[index] = j;
vertexNormalData.currentCount++;
j++;
}
var normalValues = new Float32Array(numVertices * 3);
for (i = 0; i < numVertices; i++) {
var i3 = i * 3;
vertexNormalData = normalsPerVertex[i];
Cartesian3.clone(Cartesian3.ZERO, normal);
if (vertexNormalData.count > 0) {
for (j = 0; j < vertexNormalData.count; j++) {
Cartesian3.add(normal, normalsPerTriangle[normalIndices[vertexNormalData.indexOffset + j]], normal);
}
// We can run into an issue where a vertex is used with 2 primitives that have opposite winding order.
if (Cartesian3.equalsEpsilon(Cartesian3.ZERO, normal, CesiumMath.EPSILON10)) {
Cartesian3.clone(normalsPerTriangle[normalIndices[vertexNormalData.indexOffset]], normal);
}
}
// We end up with a zero vector probably because of a degenerate triangle
if (Cartesian3.equalsEpsilon(Cartesian3.ZERO, normal, CesiumMath.EPSILON10)) {
// Default to (0,0,1)
normal.z = 1.0;
}
Cartesian3.normalize(normal, normal);
normalValues[i3] = normal.x;
normalValues[i3 + 1] = normal.y;
normalValues[i3 + 2] = normal.z;
}
geometry.attributes.normal = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 3,
values : normalValues
});
return geometry;
};
var normalScratch = new Cartesian3();
var normalScale = new Cartesian3();
var tScratch = new Cartesian3();
/**
* Computes per-vertex tangents and bitangents for a geometry containing <code>TRIANGLES</code>.
* The result is new <code>tangent</code> and <code>bitangent</code> attributes added to the geometry.
* This assumes a counter-clockwise winding order.
* <p>
* Based on <a href="http://www.terathon.com/code/tangent.html">Computing Tangent Space Basis Vectors
* for an Arbitrary Mesh</a> by Eric Lengyel.
* </p>
*
* @param {Geometry} geometry The geometry to modify.
* @returns {Geometry} The modified <code>geometry</code> argument with the computed <code>tangent</code> and <code>bitangent</code> attributes.
*
* @exception {DeveloperError} geometry.indices length must be greater than 0 and be a multiple of 3.
* @exception {DeveloperError} geometry.primitiveType must be {@link PrimitiveType.TRIANGLES}.
*
* @example
* Cesium.GeometryPipeline.computeTangentAndBiTangent(geometry);
*/
GeometryPipeline.computeTangentAndBitangent = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
var attributes = geometry.attributes;
var indices = geometry.indices;
if (!defined(attributes.position) || !defined(attributes.position.values)) {
throw new DeveloperError('geometry.attributes.position.values is required.');
}
if (!defined(attributes.normal) || !defined(attributes.normal.values)) {
throw new DeveloperError('geometry.attributes.normal.values is required.');
}
if (!defined(attributes.st) || !defined(attributes.st.values)) {
throw new DeveloperError('geometry.attributes.st.values is required.');
}
if (!defined(indices)) {
throw new DeveloperError('geometry.indices is required.');
}
if (indices.length < 2 || indices.length % 3 !== 0) {
throw new DeveloperError('geometry.indices length must be greater than 0 and be a multiple of 3.');
}
if (geometry.primitiveType !== PrimitiveType.TRIANGLES) {
throw new DeveloperError('geometry.primitiveType must be PrimitiveType.TRIANGLES.');
}
var vertices = geometry.attributes.position.values;
var normals = geometry.attributes.normal.values;
var st = geometry.attributes.st.values;
var numVertices = geometry.attributes.position.values.length / 3;
var numIndices = indices.length;
var tan1 = new Array(numVertices * 3);
for ( var i = 0; i < tan1.length; i++) {
tan1[i] = 0;
}
var i03;
var i13;
var i23;
for (i = 0; i < numIndices; i += 3) {
var i0 = indices[i];
var i1 = indices[i + 1];
var i2 = indices[i + 2];
i03 = i0 * 3;
i13 = i1 * 3;
i23 = i2 * 3;
var i02 = i0 * 2;
var i12 = i1 * 2;
var i22 = i2 * 2;
var ux = vertices[i03];
var uy = vertices[i03 + 1];
var uz = vertices[i03 + 2];
var wx = st[i02];
var wy = st[i02 + 1];
var t1 = st[i12 + 1] - wy;
var t2 = st[i22 + 1] - wy;
var r = 1.0 / ((st[i12] - wx) * t2 - (st[i22] - wx) * t1);
var sdirx = (t2 * (vertices[i13] - ux) - t1 * (vertices[i23] - ux)) * r;
var sdiry = (t2 * (vertices[i13 + 1] - uy) - t1 * (vertices[i23 + 1] - uy)) * r;
var sdirz = (t2 * (vertices[i13 + 2] - uz) - t1 * (vertices[i23 + 2] - uz)) * r;
tan1[i03] += sdirx;
tan1[i03 + 1] += sdiry;
tan1[i03 + 2] += sdirz;
tan1[i13] += sdirx;
tan1[i13 + 1] += sdiry;
tan1[i13 + 2] += sdirz;
tan1[i23] += sdirx;
tan1[i23 + 1] += sdiry;
tan1[i23 + 2] += sdirz;
}
var tangentValues = new Float32Array(numVertices * 3);
var bitangentValues = new Float32Array(numVertices * 3);
for (i = 0; i < numVertices; i++) {
i03 = i * 3;
i13 = i03 + 1;
i23 = i03 + 2;
var n = Cartesian3.fromArray(normals, i03, normalScratch);
var t = Cartesian3.fromArray(tan1, i03, tScratch);
var scalar = Cartesian3.dot(n, t);
Cartesian3.multiplyByScalar(n, scalar, normalScale);
Cartesian3.normalize(Cartesian3.subtract(t, normalScale, t), t);
tangentValues[i03] = t.x;
tangentValues[i13] = t.y;
tangentValues[i23] = t.z;
Cartesian3.normalize(Cartesian3.cross(n, t, t), t);
bitangentValues[i03] = t.x;
bitangentValues[i13] = t.y;
bitangentValues[i23] = t.z;
}
geometry.attributes.tangent = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 3,
values : tangentValues
});
geometry.attributes.bitangent = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 3,
values : bitangentValues
});
return geometry;
};
var scratchCartesian2 = new Cartesian2();
var toEncode1 = new Cartesian3();
var toEncode2 = new Cartesian3();
var toEncode3 = new Cartesian3();
var encodeResult2 = new Cartesian2();
/**
* Compresses and packs geometry normal attribute values to save memory.
*
* @param {Geometry} geometry The geometry to modify.
* @returns {Geometry} The modified <code>geometry</code> argument, with its normals compressed and packed.
*
* @example
* geometry = Cesium.GeometryPipeline.compressVertices(geometry);
*/
GeometryPipeline.compressVertices = function(geometry) {
if (!defined(geometry)) {
throw new DeveloperError('geometry is required.');
}
var extrudeAttribute = geometry.attributes.extrudeDirection;
var i;
var numVertices;
if (defined(extrudeAttribute)) {
//only shadow volumes use extrudeDirection, and shadow volumes use vertexFormat: POSITION_ONLY so we don't need to check other attributes
var extrudeDirections = extrudeAttribute.values;
numVertices = extrudeDirections.length / 3.0;
var compressedDirections = new Float32Array(numVertices * 2);
var i2 = 0;
for (i = 0; i < numVertices; ++i) {
Cartesian3.fromArray(extrudeDirections, i * 3.0, toEncode1);
if (Cartesian3.equals(toEncode1, Cartesian3.ZERO)) {
i2 += 2;
continue;
}
encodeResult2 = AttributeCompression.octEncodeInRange(toEncode1, 65535, encodeResult2);
compressedDirections[i2++] = encodeResult2.x;
compressedDirections[i2++] = encodeResult2.y;
}
geometry.attributes.compressedAttributes = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 2,
values : compressedDirections
});
delete geometry.attributes.extrudeDirection;
return geometry;
}
var normalAttribute = geometry.attributes.normal;
var stAttribute = geometry.attributes.st;
var hasNormal = defined(normalAttribute);
var hasSt = defined(stAttribute);
if (!hasNormal && !hasSt) {
return geometry;
}
var tangentAttribute = geometry.attributes.tangent;
var bitangentAttribute = geometry.attributes.bitangent;
var hasTangent = defined(tangentAttribute);
var hasBitangent = defined(bitangentAttribute);
var normals;
var st;
var tangents;
var bitangents;
if (hasNormal) {
normals = normalAttribute.values;
}
if (hasSt) {
st = stAttribute.values;
}
if (hasTangent) {
tangents = tangentAttribute.values;
}
if (hasBitangent) {
bitangents = bitangentAttribute.values;
}
var length = hasNormal ? normals.length : st.length;
var numComponents = hasNormal ? 3.0 : 2.0;
numVertices = length / numComponents;
var compressedLength = numVertices;
var numCompressedComponents = hasSt && hasNormal ? 2.0 : 1.0;
numCompressedComponents += hasTangent || hasBitangent ? 1.0 : 0.0;
compressedLength *= numCompressedComponents;
var compressedAttributes = new Float32Array(compressedLength);
var normalIndex = 0;
for (i = 0; i < numVertices; ++i) {
if (hasSt) {
Cartesian2.fromArray(st, i * 2.0, scratchCartesian2);
compressedAttributes[normalIndex++] = AttributeCompression.compressTextureCoordinates(scratchCartesian2);
}
var index = i * 3.0;
if (hasNormal && defined(tangents) && defined(bitangents)) {
Cartesian3.fromArray(normals, index, toEncode1);
Cartesian3.fromArray(tangents, index, toEncode2);
Cartesian3.fromArray(bitangents, index, toEncode3);
AttributeCompression.octPack(toEncode1, toEncode2, toEncode3, scratchCartesian2);
compressedAttributes[normalIndex++] = scratchCartesian2.x;
compressedAttributes[normalIndex++] = scratchCartesian2.y;
} else {
if (hasNormal) {
Cartesian3.fromArray(normals, index, toEncode1);
compressedAttributes[normalIndex++] = AttributeCompression.octEncodeFloat(toEncode1);
}
if (hasTangent) {
Cartesian3.fromArray(tangents, index, toEncode1);
compressedAttributes[normalIndex++] = AttributeCompression.octEncodeFloat(toEncode1);
}
if (hasBitangent) {
Cartesian3.fromArray(bitangents, index, toEncode1);
compressedAttributes[normalIndex++] = AttributeCompression.octEncodeFloat(toEncode1);
}
}
}
geometry.attributes.compressedAttributes = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : numCompressedComponents,
values : compressedAttributes
});
if (hasNormal) {
delete geometry.attributes.normal;
}
if (hasSt) {
delete geometry.attributes.st;
}
if (hasBitangent) {
delete geometry.attributes.bitangent;
}
if (hasTangent) {
delete geometry.attributes.tangent;
}
return geometry;
};
function indexTriangles(geometry) {
if (defined(geometry.indices)) {
return geometry;
}
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
if (numberOfVertices < 3) {
throw new DeveloperError('The number of vertices must be at least three.');
}
if (numberOfVertices % 3 !== 0) {
throw new DeveloperError('The number of vertices must be a multiple of three.');
}
var indices = IndexDatatype.createTypedArray(numberOfVertices, numberOfVertices);
for (var i = 0; i < numberOfVertices; ++i) {
indices[i] = i;
}
geometry.indices = indices;
return geometry;
}
function indexTriangleFan(geometry) {
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
if (numberOfVertices < 3) {
throw new DeveloperError('The number of vertices must be at least three.');
}
var indices = IndexDatatype.createTypedArray(numberOfVertices, (numberOfVertices - 2) * 3);
indices[0] = 1;
indices[1] = 0;
indices[2] = 2;
var indicesIndex = 3;
for (var i = 3; i < numberOfVertices; ++i) {
indices[indicesIndex++] = i - 1;
indices[indicesIndex++] = 0;
indices[indicesIndex++] = i;
}
geometry.indices = indices;
geometry.primitiveType = PrimitiveType.TRIANGLES;
return geometry;
}
function indexTriangleStrip(geometry) {
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
if (numberOfVertices < 3) {
throw new DeveloperError('The number of vertices must be at least 3.');
}
var indices = IndexDatatype.createTypedArray(numberOfVertices, (numberOfVertices - 2) * 3);
indices[0] = 0;
indices[1] = 1;
indices[2] = 2;
if (numberOfVertices > 3) {
indices[3] = 0;
indices[4] = 2;
indices[5] = 3;
}
var indicesIndex = 6;
for (var i = 3; i < numberOfVertices - 1; i += 2) {
indices[indicesIndex++] = i;
indices[indicesIndex++] = i - 1;
indices[indicesIndex++] = i + 1;
if (i + 2 < numberOfVertices) {
indices[indicesIndex++] = i;
indices[indicesIndex++] = i + 1;
indices[indicesIndex++] = i + 2;
}
}
geometry.indices = indices;
geometry.primitiveType = PrimitiveType.TRIANGLES;
return geometry;
}
function indexLines(geometry) {
if (defined(geometry.indices)) {
return geometry;
}
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
if (numberOfVertices < 2) {
throw new DeveloperError('The number of vertices must be at least two.');
}
if (numberOfVertices % 2 !== 0) {
throw new DeveloperError('The number of vertices must be a multiple of 2.');
}
var indices = IndexDatatype.createTypedArray(numberOfVertices, numberOfVertices);
for (var i = 0; i < numberOfVertices; ++i) {
indices[i] = i;
}
geometry.indices = indices;
return geometry;
}
function indexLineStrip(geometry) {
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
if (numberOfVertices < 2) {
throw new DeveloperError('The number of vertices must be at least two.');
}
var indices = IndexDatatype.createTypedArray(numberOfVertices, (numberOfVertices - 1) * 2);
indices[0] = 0;
indices[1] = 1;
var indicesIndex = 2;
for (var i = 2; i < numberOfVertices; ++i) {
indices[indicesIndex++] = i - 1;
indices[indicesIndex++] = i;
}
geometry.indices = indices;
geometry.primitiveType = PrimitiveType.LINES;
return geometry;
}
function indexLineLoop(geometry) {
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
if (numberOfVertices < 2) {
throw new DeveloperError('The number of vertices must be at least two.');
}
var indices = IndexDatatype.createTypedArray(numberOfVertices, numberOfVertices * 2);
indices[0] = 0;
indices[1] = 1;
var indicesIndex = 2;
for (var i = 2; i < numberOfVertices; ++i) {
indices[indicesIndex++] = i - 1;
indices[indicesIndex++] = i;
}
indices[indicesIndex++] = numberOfVertices - 1;
indices[indicesIndex] = 0;
geometry.indices = indices;
geometry.primitiveType = PrimitiveType.LINES;
return geometry;
}
function indexPrimitive(geometry) {
switch (geometry.primitiveType) {
case PrimitiveType.TRIANGLE_FAN:
return indexTriangleFan(geometry);
case PrimitiveType.TRIANGLE_STRIP:
return indexTriangleStrip(geometry);
case PrimitiveType.TRIANGLES:
return indexTriangles(geometry);
case PrimitiveType.LINE_STRIP:
return indexLineStrip(geometry);
case PrimitiveType.LINE_LOOP:
return indexLineLoop(geometry);
case PrimitiveType.LINES:
return indexLines(geometry);
}
return geometry;
}
function offsetPointFromXZPlane(p, isBehind) {
if (Math.abs(p.y) < CesiumMath.EPSILON6){
if (isBehind) {
p.y = -CesiumMath.EPSILON6;
} else {
p.y = CesiumMath.EPSILON6;
}
}
}
function offsetTriangleFromXZPlane(p0, p1, p2) {
if (p0.y !== 0.0 && p1.y !== 0.0 && p2.y !== 0.0) {
offsetPointFromXZPlane(p0, p0.y < 0.0);
offsetPointFromXZPlane(p1, p1.y < 0.0);
offsetPointFromXZPlane(p2, p2.y < 0.0);
return;
}
var p0y = Math.abs(p0.y);
var p1y = Math.abs(p1.y);
var p2y = Math.abs(p2.y);
var sign;
if (p0y > p1y) {
if (p0y > p2y) {
sign = CesiumMath.sign(p0.y);
} else {
sign = CesiumMath.sign(p2.y);
}
} else if (p1y > p2y) {
sign = CesiumMath.sign(p1.y);
} else {
sign = CesiumMath.sign(p2.y);
}
var isBehind = sign < 0.0;
offsetPointFromXZPlane(p0, isBehind);
offsetPointFromXZPlane(p1, isBehind);
offsetPointFromXZPlane(p2, isBehind);
}
var c3 = new Cartesian3();
function getXZIntersectionOffsetPoints(p, p1, u1, v1) {
Cartesian3.add(p, Cartesian3.multiplyByScalar(Cartesian3.subtract(p1, p, c3), p.y/(p.y-p1.y), c3), u1);
Cartesian3.clone(u1, v1);
offsetPointFromXZPlane(u1, true);
offsetPointFromXZPlane(v1, false);
}
var u1 = new Cartesian3();
var u2 = new Cartesian3();
var q1 = new Cartesian3();
var q2 = new Cartesian3();
var splitTriangleResult = {
positions : new Array(7),
indices : new Array(3 * 3)
};
function splitTriangle(p0, p1, p2) {
// In WGS84 coordinates, for a triangle approximately on the
// ellipsoid to cross the IDL, first it needs to be on the
// negative side of the plane x = 0.
if ((p0.x >= 0.0) || (p1.x >= 0.0) || (p2.x >= 0.0)) {
return undefined;
}
offsetTriangleFromXZPlane(p0, p1, p2);
var p0Behind = p0.y < 0.0;
var p1Behind = p1.y < 0.0;
var p2Behind = p2.y < 0.0;
var numBehind = 0;
numBehind += p0Behind ? 1 : 0;
numBehind += p1Behind ? 1 : 0;
numBehind += p2Behind ? 1 : 0;
var indices = splitTriangleResult.indices;
if (numBehind === 1) {
indices[1] = 3;
indices[2] = 4;
indices[5] = 6;
indices[7] = 6;
indices[8] = 5;
if (p0Behind) {
getXZIntersectionOffsetPoints(p0, p1, u1, q1);
getXZIntersectionOffsetPoints(p0, p2, u2, q2);
indices[0] = 0;
indices[3] = 1;
indices[4] = 2;
indices[6] = 1;
} else if (p1Behind) {
getXZIntersectionOffsetPoints(p1, p2, u1, q1);
getXZIntersectionOffsetPoints(p1, p0, u2, q2);
indices[0] = 1;
indices[3] = 2;
indices[4] = 0;
indices[6] = 2;
} else if (p2Behind) {
getXZIntersectionOffsetPoints(p2, p0, u1, q1);
getXZIntersectionOffsetPoints(p2, p1, u2, q2);
indices[0] = 2;
indices[3] = 0;
indices[4] = 1;
indices[6] = 0;
}
} else if (numBehind === 2) {
indices[2] = 4;
indices[4] = 4;
indices[5] = 3;
indices[7] = 5;
indices[8] = 6;
if (!p0Behind) {
getXZIntersectionOffsetPoints(p0, p1, u1, q1);
getXZIntersectionOffsetPoints(p0, p2, u2, q2);
indices[0] = 1;
indices[1] = 2;
indices[3] = 1;
indices[6] = 0;
} else if (!p1Behind) {
getXZIntersectionOffsetPoints(p1, p2, u1, q1);
getXZIntersectionOffsetPoints(p1, p0, u2, q2);
indices[0] = 2;
indices[1] = 0;
indices[3] = 2;
indices[6] = 1;
} else if (!p2Behind) {
getXZIntersectionOffsetPoints(p2, p0, u1, q1);
getXZIntersectionOffsetPoints(p2, p1, u2, q2);
indices[0] = 0;
indices[1] = 1;
indices[3] = 0;
indices[6] = 2;
}
}
var positions = splitTriangleResult.positions;
positions[0] = p0;
positions[1] = p1;
positions[2] = p2;
positions.length = 3;
if (numBehind === 1 || numBehind === 2) {
positions[3] = u1;
positions[4] = u2;
positions[5] = q1;
positions[6] = q2;
positions.length = 7;
}
return splitTriangleResult;
}
function updateGeometryAfterSplit(geometry, computeBoundingSphere) {
var attributes = geometry.attributes;
if (attributes.position.values.length === 0) {
return undefined;
}
for (var property in attributes) {
if (attributes.hasOwnProperty(property) &&
defined(attributes[property]) &&
defined(attributes[property].values)) {
var attribute = attributes[property];
attribute.values = ComponentDatatype.createTypedArray(attribute.componentDatatype, attribute.values);
}
}
var numberOfVertices = Geometry.computeNumberOfVertices(geometry);
geometry.indices = IndexDatatype.createTypedArray(numberOfVertices, geometry.indices);
if (computeBoundingSphere) {
geometry.boundingSphere = BoundingSphere.fromVertices(attributes.position.values);
}
return geometry;
}
function copyGeometryForSplit(geometry) {
var attributes = geometry.attributes;
var copiedAttributes = {};
for (var property in attributes) {
if (attributes.hasOwnProperty(property) &&
defined(attributes[property]) &&
defined(attributes[property].values)) {
var attribute = attributes[property];
copiedAttributes[property] = new GeometryAttribute({
componentDatatype : attribute.componentDatatype,
componentsPerAttribute : attribute.componentsPerAttribute,
normalize : attribute.normalize,
values : []
});
}
}
return new Geometry({
attributes : copiedAttributes,
indices : [],
primitiveType : geometry.primitiveType
});
}
function updateInstanceAfterSplit(instance, westGeometry, eastGeometry) {
var computeBoundingSphere = defined(instance.geometry.boundingSphere);
westGeometry = updateGeometryAfterSplit(westGeometry, computeBoundingSphere);
eastGeometry = updateGeometryAfterSplit(eastGeometry, computeBoundingSphere);
if (defined(eastGeometry) && !defined(westGeometry)) {
instance.geometry = eastGeometry;
} else if (!defined(eastGeometry) && defined(westGeometry)) {
instance.geometry = westGeometry;
} else {
instance.westHemisphereGeometry = westGeometry;
instance.eastHemisphereGeometry = eastGeometry;
instance.geometry = undefined;
}
}
var p0Scratch = new Cartesian3();
var p1Scratch = new Cartesian3();
var p2Scratch = new Cartesian3();
var barycentricScratch = new Cartesian3();
var s0Scratch = new Cartesian2();
var s1Scratch = new Cartesian2();
var s2Scratch = new Cartesian2();
function computeTriangleAttributes(i0, i1, i2, point, positions, normals, tangents, bitangents, texCoords, extrudeDirections, currentAttributes, insertedIndex) {
if (!defined(normals) && !defined(tangents) && !defined(bitangents) && !defined(texCoords) && !defined(extrudeDirections)) {
return;
}
var p0 = Cartesian3.fromArray(positions, i0 * 3, p0Scratch);
var p1 = Cartesian3.fromArray(positions, i1 * 3, p1Scratch);
var p2 = Cartesian3.fromArray(positions, i2 * 3, p2Scratch);
var coords = barycentricCoordinates(point, p0, p1, p2, barycentricScratch);
if (defined(normals)) {
var n0 = Cartesian3.fromArray(normals, i0 * 3, p0Scratch);
var n1 = Cartesian3.fromArray(normals, i1 * 3, p1Scratch);
var n2 = Cartesian3.fromArray(normals, i2 * 3, p2Scratch);
Cartesian3.multiplyByScalar(n0, coords.x, n0);
Cartesian3.multiplyByScalar(n1, coords.y, n1);
Cartesian3.multiplyByScalar(n2, coords.z, n2);
var normal = Cartesian3.add(n0, n1, n0);
Cartesian3.add(normal, n2, normal);
Cartesian3.normalize(normal, normal);
Cartesian3.pack(normal, currentAttributes.normal.values, insertedIndex * 3);
}
if (defined(extrudeDirections)) {
var d0 = Cartesian3.fromArray(extrudeDirections, i0 * 3, p0Scratch);
var d1 = Cartesian3.fromArray(extrudeDirections, i1 * 3, p1Scratch);
var d2 = Cartesian3.fromArray(extrudeDirections, i2 * 3, p2Scratch);
Cartesian3.multiplyByScalar(d0, coords.x, d0);
Cartesian3.multiplyByScalar(d1, coords.y, d1);
Cartesian3.multiplyByScalar(d2, coords.z, d2);
var direction;
if (!Cartesian3.equals(d0, Cartesian3.ZERO) || !Cartesian3.equals(d1, Cartesian3.ZERO) || !Cartesian3.equals(d2, Cartesian3.ZERO)) {
direction = Cartesian3.add(d0, d1, d0);
Cartesian3.add(direction, d2, direction);
Cartesian3.normalize(direction, direction);
} else {
direction = p0Scratch;
direction.x = 0;
direction.y = 0;
direction.z = 0;
}
Cartesian3.pack(direction, currentAttributes.extrudeDirection.values, insertedIndex * 3);
}
if (defined(tangents)) {
var t0 = Cartesian3.fromArray(tangents, i0 * 3, p0Scratch);
var t1 = Cartesian3.fromArray(tangents, i1 * 3, p1Scratch);
var t2 = Cartesian3.fromArray(tangents, i2 * 3, p2Scratch);
Cartesian3.multiplyByScalar(t0, coords.x, t0);
Cartesian3.multiplyByScalar(t1, coords.y, t1);
Cartesian3.multiplyByScalar(t2, coords.z, t2);
var tangent = Cartesian3.add(t0, t1, t0);
Cartesian3.add(tangent, t2, tangent);
Cartesian3.normalize(tangent, tangent);
Cartesian3.pack(tangent, currentAttributes.tangent.values, insertedIndex * 3);
}
if (defined(bitangents)) {
var b0 = Cartesian3.fromArray(bitangents, i0 * 3, p0Scratch);
var b1 = Cartesian3.fromArray(bitangents, i1 * 3, p1Scratch);
var b2 = Cartesian3.fromArray(bitangents, i2 * 3, p2Scratch);
Cartesian3.multiplyByScalar(b0, coords.x, b0);
Cartesian3.multiplyByScalar(b1, coords.y, b1);
Cartesian3.multiplyByScalar(b2, coords.z, b2);
var bitangent = Cartesian3.add(b0, b1, b0);
Cartesian3.add(bitangent, b2, bitangent);
Cartesian3.normalize(bitangent, bitangent);
Cartesian3.pack(bitangent, currentAttributes.bitangent.values, insertedIndex * 3);
}
if (defined(texCoords)) {
var s0 = Cartesian2.fromArray(texCoords, i0 * 2, s0Scratch);
var s1 = Cartesian2.fromArray(texCoords, i1 * 2, s1Scratch);
var s2 = Cartesian2.fromArray(texCoords, i2 * 2, s2Scratch);
Cartesian2.multiplyByScalar(s0, coords.x, s0);
Cartesian2.multiplyByScalar(s1, coords.y, s1);
Cartesian2.multiplyByScalar(s2, coords.z, s2);
var texCoord = Cartesian2.add(s0, s1, s0);
Cartesian2.add(texCoord, s2, texCoord);
Cartesian2.pack(texCoord, currentAttributes.st.values, insertedIndex * 2);
}
}
function insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, currentIndex, point) {
var insertIndex = currentAttributes.position.values.length / 3;
if (currentIndex !== -1) {
var prevIndex = indices[currentIndex];
var newIndex = currentIndexMap[prevIndex];
if (newIndex === -1) {
currentIndexMap[prevIndex] = insertIndex;
currentAttributes.position.values.push(point.x, point.y, point.z);
currentIndices.push(insertIndex);
return insertIndex;
}
currentIndices.push(newIndex);
return newIndex;
}
currentAttributes.position.values.push(point.x, point.y, point.z);
currentIndices.push(insertIndex);
return insertIndex;
}
function splitLongitudeTriangles(instance) {
var geometry = instance.geometry;
var attributes = geometry.attributes;
var positions = attributes.position.values;
var normals = (defined(attributes.normal)) ? attributes.normal.values : undefined;
var bitangents = (defined(attributes.bitangent)) ? attributes.bitangent.values : undefined;
var tangents = (defined(attributes.tangent)) ? attributes.tangent.values : undefined;
var texCoords = (defined(attributes.st)) ? attributes.st.values : undefined;
var extrudeDirections = (defined(attributes.extrudeDirection)) ? attributes.extrudeDirection.values : undefined;
var indices = geometry.indices;
var eastGeometry = copyGeometryForSplit(geometry);
var westGeometry = copyGeometryForSplit(geometry);
var currentAttributes;
var currentIndices;
var currentIndexMap;
var insertedIndex;
var i;
var westGeometryIndexMap = [];
westGeometryIndexMap.length = positions.length / 3;
var eastGeometryIndexMap = [];
eastGeometryIndexMap.length = positions.length / 3;
for (i = 0; i < westGeometryIndexMap.length; ++i) {
westGeometryIndexMap[i] = -1;
eastGeometryIndexMap[i] = -1;
}
var len = indices.length;
for (i = 0; i < len; i += 3) {
var i0 = indices[i];
var i1 = indices[i + 1];
var i2 = indices[i + 2];
var p0 = Cartesian3.fromArray(positions, i0 * 3);
var p1 = Cartesian3.fromArray(positions, i1 * 3);
var p2 = Cartesian3.fromArray(positions, i2 * 3);
var result = splitTriangle(p0, p1, p2);
if (defined(result) && result.positions.length > 3) {
var resultPositions = result.positions;
var resultIndices = result.indices;
var resultLength = resultIndices.length;
for (var j = 0; j < resultLength; ++j) {
var resultIndex = resultIndices[j];
var point = resultPositions[resultIndex];
if (point.y < 0.0) {
currentAttributes = westGeometry.attributes;
currentIndices = westGeometry.indices;
currentIndexMap = westGeometryIndexMap;
} else {
currentAttributes = eastGeometry.attributes;
currentIndices = eastGeometry.indices;
currentIndexMap = eastGeometryIndexMap;
}
insertedIndex = insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, resultIndex < 3 ? i + resultIndex : -1, point);
computeTriangleAttributes(i0, i1, i2, point, positions, normals, tangents, bitangents, texCoords, extrudeDirections, currentAttributes, insertedIndex);
}
} else {
if (defined(result)) {
p0 = result.positions[0];
p1 = result.positions[1];
p2 = result.positions[2];
}
if (p0.y < 0.0) {
currentAttributes = westGeometry.attributes;
currentIndices = westGeometry.indices;
currentIndexMap = westGeometryIndexMap;
} else {
currentAttributes = eastGeometry.attributes;
currentIndices = eastGeometry.indices;
currentIndexMap = eastGeometryIndexMap;
}
insertedIndex = insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, i, p0);
computeTriangleAttributes(i0, i1, i2, p0, positions, normals, tangents, bitangents, texCoords, extrudeDirections, currentAttributes, insertedIndex);
insertedIndex = insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, i + 1, p1);
computeTriangleAttributes(i0, i1, i2, p1, positions, normals, tangents, bitangents, texCoords, extrudeDirections, currentAttributes, insertedIndex);
insertedIndex = insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, i + 2, p2);
computeTriangleAttributes(i0, i1, i2, p2, positions, normals, tangents, bitangents, texCoords, extrudeDirections, currentAttributes, insertedIndex);
}
}
updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
}
var xzPlane = Plane.fromPointNormal(Cartesian3.ZERO, Cartesian3.UNIT_Y);
var offsetScratch = new Cartesian3();
var offsetPointScratch = new Cartesian3();
function splitLongitudeLines(instance) {
var geometry = instance.geometry;
var attributes = geometry.attributes;
var positions = attributes.position.values;
var indices = geometry.indices;
var eastGeometry = copyGeometryForSplit(geometry);
var westGeometry = copyGeometryForSplit(geometry);
var i;
var length = indices.length;
var westGeometryIndexMap = [];
westGeometryIndexMap.length = positions.length / 3;
var eastGeometryIndexMap = [];
eastGeometryIndexMap.length = positions.length / 3;
for (i = 0; i < westGeometryIndexMap.length; ++i) {
westGeometryIndexMap[i] = -1;
eastGeometryIndexMap[i] = -1;
}
for (i = 0; i < length; i += 2) {
var i0 = indices[i];
var i1 = indices[i + 1];
var p0 = Cartesian3.fromArray(positions, i0 * 3, p0Scratch);
var p1 = Cartesian3.fromArray(positions, i1 * 3, p1Scratch);
if (Math.abs(p0.y) < CesiumMath.EPSILON6){
if (p0.y < 0.0) {
p0.y = -CesiumMath.EPSILON6;
} else {
p0.y = CesiumMath.EPSILON6;
}
}
if (Math.abs(p1.y) < CesiumMath.EPSILON6){
if (p1.y < 0.0) {
p1.y = -CesiumMath.EPSILON6;
} else {
p1.y = CesiumMath.EPSILON6;
}
}
var p0Attributes = eastGeometry.attributes;
var p0Indices = eastGeometry.indices;
var p0IndexMap = eastGeometryIndexMap;
var p1Attributes = westGeometry.attributes;
var p1Indices = westGeometry.indices;
var p1IndexMap = westGeometryIndexMap;
var intersection = IntersectionTests.lineSegmentPlane(p0, p1, xzPlane, p2Scratch);
if (defined(intersection)) {
// move point on the xz-plane slightly away from the plane
var offset = Cartesian3.multiplyByScalar(Cartesian3.UNIT_Y, 5.0 * CesiumMath.EPSILON9, offsetScratch);
if (p0.y < 0.0) {
Cartesian3.negate(offset, offset);
p0Attributes = westGeometry.attributes;
p0Indices = westGeometry.indices;
p0IndexMap = westGeometryIndexMap;
p1Attributes = eastGeometry.attributes;
p1Indices = eastGeometry.indices;
p1IndexMap = eastGeometryIndexMap;
}
var offsetPoint = Cartesian3.add(intersection, offset, offsetPointScratch);
insertSplitPoint(p0Attributes, p0Indices, p0IndexMap, indices, i, p0);
insertSplitPoint(p0Attributes, p0Indices, p0IndexMap, indices, -1, offsetPoint);
Cartesian3.negate(offset, offset);
Cartesian3.add(intersection, offset, offsetPoint);
insertSplitPoint(p1Attributes, p1Indices, p1IndexMap, indices, -1, offsetPoint);
insertSplitPoint(p1Attributes, p1Indices, p1IndexMap, indices, i + 1, p1);
} else {
var currentAttributes;
var currentIndices;
var currentIndexMap;
if (p0.y < 0.0) {
currentAttributes = westGeometry.attributes;
currentIndices = westGeometry.indices;
currentIndexMap = westGeometryIndexMap;
} else {
currentAttributes = eastGeometry.attributes;
currentIndices = eastGeometry.indices;
currentIndexMap = eastGeometryIndexMap;
}
insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, i, p0);
insertSplitPoint(currentAttributes, currentIndices, currentIndexMap, indices, i + 1, p1);
}
}
updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
}
var cartesian2Scratch0 = new Cartesian2();
var cartesian2Scratch1 = new Cartesian2();
var cartesian3Scratch0 = new Cartesian3();
var cartesian3Scratch2 = new Cartesian3();
var cartesian3Scratch3 = new Cartesian3();
var cartesian3Scratch4 = new Cartesian3();
var cartesian3Scratch5 = new Cartesian3();
var cartesian3Scratch6 = new Cartesian3();
var cartesian4Scratch0 = new Cartesian4();
function updateAdjacencyAfterSplit(geometry) {
var attributes = geometry.attributes;
var positions = attributes.position.values;
var prevPositions = attributes.prevPosition.values;
var nextPositions = attributes.nextPosition.values;
var length = positions.length;
for (var j = 0; j < length; j += 3) {
var position = Cartesian3.unpack(positions, j, cartesian3Scratch0);
if (position.x > 0.0) {
continue;
}
var prevPosition = Cartesian3.unpack(prevPositions, j, cartesian3Scratch2);
if ((position.y < 0.0 && prevPosition.y > 0.0) || (position.y > 0.0 && prevPosition.y < 0.0)) {
if (j - 3 > 0) {
prevPositions[j] = positions[j - 3];
prevPositions[j + 1] = positions[j - 2];
prevPositions[j + 2] = positions[j - 1];
} else {
Cartesian3.pack(position, prevPositions, j);
}
}
var nextPosition = Cartesian3.unpack(nextPositions, j, cartesian3Scratch3);
if ((position.y < 0.0 && nextPosition.y > 0.0) || (position.y > 0.0 && nextPosition.y < 0.0)) {
if (j + 3 < length) {
nextPositions[j] = positions[j + 3];
nextPositions[j + 1] = positions[j + 4];
nextPositions[j + 2] = positions[j + 5];
} else {
Cartesian3.pack(position, nextPositions, j);
}
}
}
}
var offsetScalar = 5.0 * CesiumMath.EPSILON9;
var coplanarOffset = CesiumMath.EPSILON6;
function splitLongitudePolyline(instance) {
var geometry = instance.geometry;
var attributes = geometry.attributes;
var positions = attributes.position.values;
var prevPositions = attributes.prevPosition.values;
var nextPositions = attributes.nextPosition.values;
var expandAndWidths = attributes.expandAndWidth.values;
var texCoords = (defined(attributes.st)) ? attributes.st.values : undefined;
var colors = (defined(attributes.color)) ? attributes.color.values : undefined;
var eastGeometry = copyGeometryForSplit(geometry);
var westGeometry = copyGeometryForSplit(geometry);
var i;
var j;
var index;
var intersectionFound = false;
var length = positions.length / 3;
for (i = 0; i < length; i += 4) {
var i0 = i;
var i2 = i + 2;
var p0 = Cartesian3.fromArray(positions, i0 * 3, cartesian3Scratch0);
var p2 = Cartesian3.fromArray(positions, i2 * 3, cartesian3Scratch2);
// Offset points that are close to the 180 longitude and change the previous/next point
// to be the same offset point so it can be projected to 2D. There is special handling in the
// shader for when position == prevPosition || position == nextPosition.
if (Math.abs(p0.y) < coplanarOffset) {
p0.y = coplanarOffset * (p2.y < 0.0 ? -1.0 : 1.0);
positions[i * 3 + 1] = p0.y;
positions[(i + 1) * 3 + 1] = p0.y;
for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
prevPositions[j] = positions[i * 3];
prevPositions[j + 1] = positions[i * 3 + 1];
prevPositions[j + 2] = positions[i * 3 + 2];
}
}
// Do the same but for when the line crosses 180 longitude in the opposite direction.
if (Math.abs(p2.y) < coplanarOffset) {
p2.y = coplanarOffset * (p0.y < 0.0 ? -1.0 : 1.0);
positions[(i + 2) * 3 + 1] = p2.y;
positions[(i + 3) * 3 + 1] = p2.y;
for (j = i0 * 3; j < i0 * 3 + 4 * 3; j += 3) {
nextPositions[j] = positions[(i + 2) * 3];
nextPositions[j + 1] = positions[(i + 2) * 3 + 1];
nextPositions[j + 2] = positions[(i + 2) * 3 + 2];
}
}
var p0Attributes = eastGeometry.attributes;
var p0Indices = eastGeometry.indices;
var p2Attributes = westGeometry.attributes;
var p2Indices = westGeometry.indices;
var intersection = IntersectionTests.lineSegmentPlane(p0, p2, xzPlane, cartesian3Scratch4);
if (defined(intersection)) {
intersectionFound = true;
// move point on the xz-plane slightly away from the plane
var offset = Cartesian3.multiplyByScalar(Cartesian3.UNIT_Y, offsetScalar, cartesian3Scratch5);
if (p0.y < 0.0) {
Cartesian3.negate(offset, offset);
p0Attributes = westGeometry.attributes;
p0Indices = westGeometry.indices;
p2Attributes = eastGeometry.attributes;
p2Indices = eastGeometry.indices;
}
var offsetPoint = Cartesian3.add(intersection, offset, cartesian3Scratch6);
p0Attributes.position.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
p0Attributes.position.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p0Attributes.position.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p0Attributes.prevPosition.values.push(prevPositions[i0 * 3], prevPositions[i0 * 3 + 1], prevPositions[i0 * 3 + 2]);
p0Attributes.prevPosition.values.push(prevPositions[i0 * 3 + 3], prevPositions[i0 * 3 + 4], prevPositions[i0 * 3 + 5]);
p0Attributes.prevPosition.values.push(p0.x, p0.y, p0.z, p0.x, p0.y, p0.z);
p0Attributes.nextPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p0Attributes.nextPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p0Attributes.nextPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p0Attributes.nextPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
Cartesian3.negate(offset, offset);
Cartesian3.add(intersection, offset, offsetPoint);
p2Attributes.position.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p2Attributes.position.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p2Attributes.position.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
p2Attributes.prevPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p2Attributes.prevPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p2Attributes.prevPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p2Attributes.prevPosition.values.push(offsetPoint.x, offsetPoint.y, offsetPoint.z);
p2Attributes.nextPosition.values.push(p2.x, p2.y, p2.z, p2.x, p2.y, p2.z);
p2Attributes.nextPosition.values.push(nextPositions[i2 * 3], nextPositions[i2 * 3 + 1], nextPositions[i2 * 3 + 2]);
p2Attributes.nextPosition.values.push(nextPositions[i2 * 3 + 3], nextPositions[i2 * 3 + 4], nextPositions[i2 * 3 + 5]);
var ew0 = Cartesian2.fromArray(expandAndWidths, i0 * 2, cartesian2Scratch0);
var width = Math.abs(ew0.y);
p0Attributes.expandAndWidth.values.push(-1, width, 1, width);
p0Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
p2Attributes.expandAndWidth.values.push(-1, width, 1, width);
p2Attributes.expandAndWidth.values.push(-1, -width, 1, -width);
var t = Cartesian3.magnitudeSquared(Cartesian3.subtract(intersection, p0, cartesian3Scratch3));
t /= Cartesian3.magnitudeSquared(Cartesian3.subtract(p2, p0, cartesian3Scratch3));
if (defined(colors)) {
var c0 = Cartesian4.fromArray(colors, i0 * 4, cartesian4Scratch0);
var c2 = Cartesian4.fromArray(colors, i2 * 4, cartesian4Scratch0);
var r = CesiumMath.lerp(c0.x, c2.x, t);
var g = CesiumMath.lerp(c0.y, c2.y, t);
var b = CesiumMath.lerp(c0.z, c2.z, t);
var a = CesiumMath.lerp(c0.w, c2.w, t);
for (j = i0 * 4; j < i0 * 4 + 2 * 4; ++j) {
p0Attributes.color.values.push(colors[j]);
}
p0Attributes.color.values.push(r, g, b, a);
p0Attributes.color.values.push(r, g, b, a);
p2Attributes.color.values.push(r, g, b, a);
p2Attributes.color.values.push(r, g, b, a);
for (j = i2 * 4; j < i2 * 4 + 2 * 4; ++j) {
p2Attributes.color.values.push(colors[j]);
}
}
if (defined(texCoords)) {
var s0 = Cartesian2.fromArray(texCoords, i0 * 2, cartesian2Scratch0);
var s3 = Cartesian2.fromArray(texCoords, (i + 3) * 2, cartesian2Scratch1);
var sx = CesiumMath.lerp(s0.x, s3.x, t);
for (j = i0 * 2; j < i0 * 2 + 2 * 2; ++j) {
p0Attributes.st.values.push(texCoords[j]);
}
p0Attributes.st.values.push(sx, s0.y);
p0Attributes.st.values.push(sx, s3.y);
p2Attributes.st.values.push(sx, s0.y);
p2Attributes.st.values.push(sx, s3.y);
for (j = i2 * 2; j < i2 * 2 + 2 * 2; ++j) {
p2Attributes.st.values.push(texCoords[j]);
}
}
index = p0Attributes.position.values.length / 3 - 4;
p0Indices.push(index, index + 2, index + 1);
p0Indices.push(index + 1, index + 2, index + 3);
index = p2Attributes.position.values.length / 3 - 4;
p2Indices.push(index, index + 2, index + 1);
p2Indices.push(index + 1, index + 2, index + 3);
} else {
var currentAttributes;
var currentIndices;
if (p0.y < 0.0) {
currentAttributes = westGeometry.attributes;
currentIndices = westGeometry.indices;
} else {
currentAttributes = eastGeometry.attributes;
currentIndices = eastGeometry.indices;
}
currentAttributes.position.values.push(p0.x, p0.y, p0.z);
currentAttributes.position.values.push(p0.x, p0.y, p0.z);
currentAttributes.position.values.push(p2.x, p2.y, p2.z);
currentAttributes.position.values.push(p2.x, p2.y, p2.z);
for (j = i * 3; j < i * 3 + 4 * 3; ++j) {
currentAttributes.prevPosition.values.push(prevPositions[j]);
currentAttributes.nextPosition.values.push(nextPositions[j]);
}
for (j = i * 2; j < i * 2 + 4 * 2; ++j) {
currentAttributes.expandAndWidth.values.push(expandAndWidths[j]);
if (defined(texCoords)) {
currentAttributes.st.values.push(texCoords[j]);
}
}
if (defined(colors)) {
for (j = i * 4; j < i * 4 + 4 * 4; ++j) {
currentAttributes.color.values.push(colors[j]);
}
}
index = currentAttributes.position.values.length / 3 - 4;
currentIndices.push(index, index + 2, index + 1);
currentIndices.push(index + 1, index + 2, index + 3);
}
}
if (intersectionFound) {
updateAdjacencyAfterSplit(westGeometry);
updateAdjacencyAfterSplit(eastGeometry);
}
updateInstanceAfterSplit(instance, westGeometry, eastGeometry);
}
/**
* Splits the instances's geometry, by introducing new vertices and indices,that
* intersect the International Date Line and Prime Meridian so that no primitives cross longitude
* -180/180 degrees. This is not required for 3D drawing, but is required for
* correcting drawing in 2D and Columbus view.
*
* @private
*
* @param {GeometryInstance} instance The instance to modify.
* @returns {GeometryInstance} The modified <code>instance</code> argument, with it's geometry split at the International Date Line.
*
* @example
* instance = Cesium.GeometryPipeline.splitLongitude(instance);
*/
GeometryPipeline.splitLongitude = function(instance) {
if (!defined(instance)) {
throw new DeveloperError('instance is required.');
}
var geometry = instance.geometry;
var boundingSphere = geometry.boundingSphere;
if (defined(boundingSphere)) {
var minX = boundingSphere.center.x - boundingSphere.radius;
if (minX > 0 || BoundingSphere.intersectPlane(boundingSphere, Plane.ORIGIN_ZX_PLANE) !== Intersect.INTERSECTING) {
return instance;
}
}
if (geometry.geometryType !== GeometryType.NONE) {
switch (geometry.geometryType) {
case GeometryType.POLYLINES:
splitLongitudePolyline(instance);
break;
case GeometryType.TRIANGLES:
splitLongitudeTriangles(instance);
break;
case GeometryType.LINES:
splitLongitudeLines(instance);
break;
}
} else {
indexPrimitive(geometry);
if (geometry.primitiveType === PrimitiveType.TRIANGLES) {
splitLongitudeTriangles(instance);
} else if (geometry.primitiveType === PrimitiveType.LINES) {
splitLongitudeLines(instance);
}
}
return instance;
};
return GeometryPipeline;
});
/*global define*/
define('Core/WebMercatorProjection',[
'./Cartesian3',
'./Cartographic',
'./defaultValue',
'./defined',
'./defineProperties',
'./DeveloperError',
'./Ellipsoid',
'./Math'
], function(
Cartesian3,
Cartographic,
defaultValue,
defined,
defineProperties,
DeveloperError,
Ellipsoid,
CesiumMath) {
'use strict';
/**
* The map projection used by Google Maps, Bing Maps, and most of ArcGIS Online, EPSG:3857. This
* projection use longitude and latitude expressed with the WGS84 and transforms them to Mercator using
* the spherical (rather than ellipsoidal) equations.
*
* @alias WebMercatorProjection
* @constructor
*
* @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid.
*
* @see GeographicProjection
*/
function WebMercatorProjection(ellipsoid) {
this._ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
this._semimajorAxis = this._ellipsoid.maximumRadius;
this._oneOverSemimajorAxis = 1.0 / this._semimajorAxis;
}
defineProperties(WebMercatorProjection.prototype, {
/**
* Gets the {@link Ellipsoid}.
*
* @memberof WebMercatorProjection.prototype
*
* @type {Ellipsoid}
* @readonly
*/
ellipsoid : {
get : function() {
return this._ellipsoid;
}
}
});
/**
* Converts a Mercator angle, in the range -PI to PI, to a geodetic latitude
* in the range -PI/2 to PI/2.
*
* @param {Number} mercatorAngle The angle to convert.
* @returns {Number} The geodetic latitude in radians.
*/
WebMercatorProjection.mercatorAngleToGeodeticLatitude = function(mercatorAngle) {
return CesiumMath.PI_OVER_TWO - (2.0 * Math.atan(Math.exp(-mercatorAngle)));
};
/**
* Converts a geodetic latitude in radians, in the range -PI/2 to PI/2, to a Mercator
* angle in the range -PI to PI.
*
* @param {Number} latitude The geodetic latitude in radians.
* @returns {Number} The Mercator angle.
*/
WebMercatorProjection.geodeticLatitudeToMercatorAngle = function(latitude) {
// Clamp the latitude coordinate to the valid Mercator bounds.
if (latitude > WebMercatorProjection.MaximumLatitude) {
latitude = WebMercatorProjection.MaximumLatitude;
} else if (latitude < -WebMercatorProjection.MaximumLatitude) {
latitude = -WebMercatorProjection.MaximumLatitude;
}
var sinLatitude = Math.sin(latitude);
return 0.5 * Math.log((1.0 + sinLatitude) / (1.0 - sinLatitude));
};
/**
* The maximum latitude (both North and South) supported by a Web Mercator
* (EPSG:3857) projection. Technically, the Mercator projection is defined
* for any latitude up to (but not including) 90 degrees, but it makes sense
* to cut it off sooner because it grows exponentially with increasing latitude.
* The logic behind this particular cutoff value, which is the one used by
* Google Maps, Bing Maps, and Esri, is that it makes the projection
* square. That is, the rectangle is equal in the X and Y directions.
*
* The constant value is computed by calling:
* WebMercatorProjection.mercatorAngleToGeodeticLatitude(Math.PI)
*
* @type {Number}
*/
WebMercatorProjection.MaximumLatitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(Math.PI);
/**
* Converts geodetic ellipsoid coordinates, in radians, to the equivalent Web Mercator
* X, Y, Z coordinates expressed in meters and returned in a {@link Cartesian3}. The height
* is copied unmodified to the Z coordinate.
*
* @param {Cartographic} cartographic The cartographic coordinates in radians.
* @param {Cartesian3} [result] The instance to which to copy the result, or undefined if a
* new instance should be created.
* @returns {Cartesian3} The equivalent web mercator X, Y, Z coordinates, in meters.
*/
WebMercatorProjection.prototype.project = function(cartographic, result) {
var semimajorAxis = this._semimajorAxis;
var x = cartographic.longitude * semimajorAxis;
var y = WebMercatorProjection.geodeticLatitudeToMercatorAngle(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;
};
/**
* Converts Web Mercator X, Y coordinates, expressed in meters, to a {@link Cartographic}
* containing geodetic ellipsoid coordinates. The Z coordinate is copied unmodified to the
* height.
*
* @param {Cartesian3} cartesian The web mercator Cartesian position to unrproject with height (z) in meters.
* @param {Cartographic} [result] The instance to which to copy the result, or undefined if a
* new instance should be created.
* @returns {Cartographic} The equivalent cartographic coordinates.
*/
WebMercatorProjection.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 = WebMercatorProjection.mercatorAngleToGeodeticLatitude(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 WebMercatorProjection;
});
/*global define*/
define('Scene/PrimitivePipeline',[
'../Core/BoundingSphere',
'../Core/ComponentDatatype',
'../Core/defined',
'../Core/DeveloperError',
'../Core/Ellipsoid',
'../Core/FeatureDetection',
'../Core/GeographicProjection',
'../Core/Geometry',
'../Core/GeometryAttribute',
'../Core/GeometryAttributes',
'../Core/GeometryPipeline',
'../Core/IndexDatatype',
'../Core/Matrix4',
'../Core/WebMercatorProjection'
], function(
BoundingSphere,
ComponentDatatype,
defined,
DeveloperError,
Ellipsoid,
FeatureDetection,
GeographicProjection,
Geometry,
GeometryAttribute,
GeometryAttributes,
GeometryPipeline,
IndexDatatype,
Matrix4,
WebMercatorProjection) {
'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 {};
}
function transformToWorldCoordinates(instances, primitiveModelMatrix, scene3DOnly) {
var toWorld = !scene3DOnly;
var length = instances.length;
var i;
if (!toWorld && (length > 1)) {
var modelMatrix = instances[0].modelMatrix;
for (i = 1; i < length; ++i) {
if (!Matrix4.equals(modelMatrix, instances[i].modelMatrix)) {
toWorld = true;
break;
}
}
}
if (toWorld) {
for (i = 0; i < length; ++i) {
if (defined(instances[i].geometry)) {
GeometryPipeline.transformToWorldCoordinates(instances[i]);
}
}
} else {
// Leave geometry in local coordinate system; auto update model-matrix.
Matrix4.multiplyTransformation(primitiveModelMatrix, instances[0].modelMatrix, primitiveModelMatrix);
}
}
function addGeometryBatchId(geometry, batchId) {
var attributes = geometry.attributes;
var positionAttr = attributes.position;
var numberOfComponents = positionAttr.values.length / positionAttr.componentsPerAttribute;
attributes.batchId = new GeometryAttribute({
componentDatatype : ComponentDatatype.FLOAT,
componentsPerAttribute : 1,
values : new Float32Array(numberOfComponents)
});
var values = attributes.batchId.values;
for (var j = 0; j < numberOfComponents; ++j) {
values[j] = batchId;
}
}
function addBatchIds(instances) {
var length = instances.length;
for (var i = 0; i < length; ++i) {
var instance = instances[i];
if (defined(instance.geometry)) {
addGeometryBatchId(instance.geometry, i);
} else if (defined(instance.westHemisphereGeometry) && defined(instance.eastHemisphereGeometry)) {
addGeometryBatchId(instance.westHemisphereGeometry, i);
addGeometryBatchId(instance.eastHemisphereGeometry, i);
}
}
}
function geometryPipeline(parameters) {
var instances = parameters.instances;
var projection = parameters.projection;
var uintIndexSupport = parameters.elementIndexUintSupported;
var scene3DOnly = parameters.scene3DOnly;
var vertexCacheOptimize = parameters.vertexCacheOptimize;
var compressVertices = parameters.compressVertices;
var modelMatrix = parameters.modelMatrix;
var i;
var geometry;
var primitiveType;
var length = instances.length;
for (i = 0 ; i < length; ++i) {
if (defined(instances[i].geometry)) {
primitiveType = instances[i].geometry.primitiveType;
break;
}
}
for (i = 1; i < length; ++i) {
if (defined(instances[i].geometry) && instances[i].geometry.primitiveType !== primitiveType) {
throw new DeveloperError('All instance geometries must have the same primitiveType.');
}
}
// Unify to world coordinates before combining.
transformToWorldCoordinates(instances, modelMatrix, scene3DOnly);
// Clip to IDL
if (!scene3DOnly) {
for (i = 0; i < length; ++i) {
if (defined(instances[i].geometry)) {
GeometryPipeline.splitLongitude(instances[i]);
}
}
}
addBatchIds(instances);
// Optimize for vertex shader caches
if (vertexCacheOptimize) {
for (i = 0; i < length; ++i) {
var instance = instances[i];
if (defined(instance.geometry)) {
GeometryPipeline.reorderForPostVertexCache(instance.geometry);
GeometryPipeline.reorderForPreVertexCache(instance.geometry);
} else if (defined(instance.westHemisphereGeometry) && defined(instance.eastHemisphereGeometry)) {
GeometryPipeline.reorderForPostVertexCache(instance.westHemisphereGeometry);
GeometryPipeline.reorderForPreVertexCache(instance.westHemisphereGeometry);
GeometryPipeline.reorderForPostVertexCache(instance.eastHemisphereGeometry);
GeometryPipeline.reorderForPreVertexCache(instance.eastHemisphereGeometry);
}
}
}
// Combine into single geometry for better rendering performance.
var geometries = GeometryPipeline.combineInstances(instances);
length = geometries.length;
for (i = 0; i < length; ++i) {
geometry = geometries[i];
// Split positions for GPU RTE
var attributes = geometry.attributes;
var name;
if (!scene3DOnly) {
for (name in attributes) {
if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype.DOUBLE) {
var name3D = name + '3D';
var name2D = name + '2D';
// Compute 2D positions
GeometryPipeline.projectTo2D(geometry, name, name3D, name2D, projection);
if (defined(geometry.boundingSphere) && name === 'position') {
geometry.boundingSphereCV = BoundingSphere.fromVertices(geometry.attributes.position2D.values);
}
GeometryPipeline.encodeAttribute(geometry, name3D, name3D + 'High', name3D + 'Low');
GeometryPipeline.encodeAttribute(geometry, name2D, name2D + 'High', name2D + 'Low');
}
}
} else {
for (name in attributes) {
if (attributes.hasOwnProperty(name) && attributes[name].componentDatatype === ComponentDatatype.DOUBLE) {
GeometryPipeline.encodeAttribute(geometry, name, name + '3DHigh', name + '3DLow');
}
}
}
// oct encode and pack normals, compress texture coordinates
if (compressVertices) {
GeometryPipeline.compressVertices(geometry);
}
}
if (!uintIndexSupport) {
// Break into multiple geometries to fit within unsigned short indices if needed
var splitGeometries = [];
length = geometries.length;
for (i = 0; i < length; ++i) {
geometry = geometries[i];
splitGeometries = splitGeometries.concat(GeometryPipeline.fitToUnsignedShortIndices(geometry));
}
geometries = splitGeometries;
}
return geometries;
}
function createPickOffsets(instances, geometryName, geometries, pickOffsets) {
var offset;
var indexCount;
var geometryIndex;
var offsetIndex = pickOffsets.length - 1;
if (offsetIndex >= 0) {
var pickOffset = pickOffsets[offsetIndex];
offset = pickOffset.offset + pickOffset.count;
geometryIndex = pickOffset.index;
indexCount = geometries[geometryIndex].indices.length;
} else {
offset = 0;
geometryIndex = 0;
indexCount = geometries[geometryIndex].indices.length;
}
var length = instances.length;
for (var i = 0; i < length; ++i) {
var instance = instances[i];
var geometry = instance[geometryName];
if (!defined(geometry)) {
continue;
}
var count = geometry.indices.length;
if (offset + count > indexCount) {
offset = 0;
indexCount = geometries[++geometryIndex].indices.length;
}
pickOffsets.push({
index : geometryIndex,
offset : offset,
count : count
});
offset += count;
}
}
function createInstancePickOffsets(instances, geometries) {
var pickOffsets = [];
createPickOffsets(instances, 'geometry', geometries, pickOffsets);
createPickOffsets(instances, 'westHemisphereGeometry', geometries, pickOffsets);
createPickOffsets(instances, 'eastHemisphereGeometry', geometries, pickOffsets);
return pickOffsets;
}
/**
* @private
*/
var PrimitivePipeline = {};
/**
* @private
*/
PrimitivePipeline.combineGeometry = function(parameters) {
var geometries;
var attributeLocations;
var instances = parameters.instances;
var length = instances.length;
if (length > 0) {
geometries = geometryPipeline(parameters);
if (geometries.length > 0) {
attributeLocations = GeometryPipeline.createAttributeLocations(geometries[0]);
}
}
var pickOffsets;
if (parameters.createPickOffsets && geometries.length > 0) {
pickOffsets = createInstancePickOffsets(instances, geometries);
}
var boundingSpheres = new Array(length);
var boundingSpheresCV = new Array(length);
for (var i = 0; i < length; ++i) {
var instance = instances[i];
var geometry = instance.geometry;
if (defined(geometry)) {
boundingSpheres[i] = geometry.boundingSphere;
boundingSpheresCV[i] = geometry.boundingSphereCV;
}
var eastHemisphereGeometry = instance.eastHemisphereGeometry;
var westHemisphereGeometry = instance.westHemisphereGeometry;
if (defined(eastHemisphereGeometry) && defined(westHemisphereGeometry)) {
if (defined(eastHemisphereGeometry.boundingSphere) && defined(westHemisphereGeometry.boundingSphere)) {
boundingSpheres[i] = BoundingSphere.union(eastHemisphereGeometry.boundingSphere, westHemisphereGeometry.boundingSphere);
}
if (defined(eastHemisphereGeometry.boundingSphereCV) && defined(westHemisphereGeometry.boundingSphereCV)) {
boundingSpheresCV[i] = BoundingSphere.union(eastHemisphereGeometry.boundingSphereCV, westHemisphereGeometry.boundingSphereCV);
}
}
}
return {
geometries : geometries,
modelMatrix : parameters.modelMatrix,
attributeLocations : attributeLocations,
pickOffsets : pickOffsets,
boundingSpheres : boundingSpheres,
boundingSpheresCV : boundingSpheresCV
};
};
function transferGeometry(geometry, transferableObjects) {
var attributes = geometry.attributes;
for ( var name in attributes) {
if (attributes.hasOwnProperty(name)) {
var attribute = attributes[name];
if (defined(attribute) && defined(attribute.values)) {
transferableObjects.push(attribute.values.buffer);
}
}
}
if (defined(geometry.indices)) {
transferableObjects.push(geometry.indices.buffer);
}
}
function transferGeometries(geometries, transferableObjects) {
var length = geometries.length;
for (var i = 0; i < length; ++i) {
transferGeometry(geometries[i], transferableObjects);
}
}
// This function was created by simplifying packCreateGeometryResults into a count-only operation.
function countCreateGeometryResults(items) {
var count = 1;
var length = items.length;
for (var i = 0; i < length; i++) {
var geometry = items[i];
++count;
if (!defined(geometry)) {
continue;
}
var attributes = geometry.attributes;
count += 6 + 2 * BoundingSphere.packedLength + (defined(geometry.indices) ? geometry.indices.length : 0);
for ( var property in attributes) {
if (attributes.hasOwnProperty(property) && defined(attributes[property])) {
var attribute = attributes[property];
count += 5 + attribute.values.length;
}
}
}
return count;
}
/**
* @private
*/
PrimitivePipeline.packCreateGeometryResults = function(items, transferableObjects) {
var packedData = new Float64Array(countCreateGeometryResults(items));
var stringTable = [];
var stringHash = {};
var length = items.length;
var count = 0;
packedData[count++] = length;
for (var i = 0; i < length; i++) {
var geometry = items[i];
var validGeometry = defined(geometry);
packedData[count++] = validGeometry ? 1.0 : 0.0;
if (!validGeometry) {
continue;
}
packedData[count++] = geometry.primitiveType;
packedData[count++] = geometry.geometryType;
var validBoundingSphere = defined(geometry.boundingSphere) ? 1.0 : 0.0;
packedData[count++] = validBoundingSphere;
if (validBoundingSphere) {
BoundingSphere.pack(geometry.boundingSphere, packedData, count);
}
count += BoundingSphere.packedLength;
var validBoundingSphereCV = defined(geometry.boundingSphereCV) ? 1.0 : 0.0;
packedData[count++] = validBoundingSphereCV;
if (validBoundingSphereCV) {
BoundingSphere.pack(geometry.boundingSphereCV, packedData, count);
}
count += BoundingSphere.packedLength;
var attributes = geometry.attributes;
var attributesToWrite = [];
for ( var property in attributes) {
if (attributes.hasOwnProperty(property) && defined(attributes[property])) {
attributesToWrite.push(property);
if (!defined(stringHash[property])) {
stringHash[property] = stringTable.length;
stringTable.push(property);
}
}
}
packedData[count++] = attributesToWrite.length;
for (var q = 0; q < attributesToWrite.length; q++) {
var name = attributesToWrite[q];
var attribute = attributes[name];
packedData[count++] = stringHash[name];
packedData[count++] = attribute.componentDatatype;
packedData[count++] = attribute.componentsPerAttribute;
packedData[count++] = attribute.normalize ? 1 : 0;
packedData[count++] = attribute.values.length;
packedData.set(attribute.values, count);
count += attribute.values.length;
}
var indicesLength = defined(geometry.indices) ? geometry.indices.length : 0;
packedData[count++] = indicesLength;
if (indicesLength > 0) {
packedData.set(geometry.indices, count);
count += indicesLength;
}
}
transferableObjects.push(packedData.buffer);
return {
stringTable : stringTable,
packedData : packedData
};
};
/**
* @private
*/
PrimitivePipeline.unpackCreateGeometryResults = function(createGeometryResult) {
var stringTable = createGeometryResult.stringTable;
var packedGeometry = createGeometryResult.packedData;
var i;
var result = new Array(packedGeometry[0]);
var resultIndex = 0;
var packedGeometryIndex = 1;
while (packedGeometryIndex < packedGeometry.length) {
var valid = packedGeometry[packedGeometryIndex++] === 1.0;
if (!valid) {
result[resultIndex++] = undefined;
continue;
}
var primitiveType = packedGeometry[packedGeometryIndex++];
var geometryType = packedGeometry[packedGeometryIndex++];
var boundingSphere;
var boundingSphereCV;
var validBoundingSphere = packedGeometry[packedGeometryIndex++] === 1.0;
if (validBoundingSphere) {
boundingSphere = BoundingSphere.unpack(packedGeometry, packedGeometryIndex);
}
packedGeometryIndex += BoundingSphere.packedLength;
var validBoundingSphereCV = packedGeometry[packedGeometryIndex++] === 1.0;
if (validBoundingSphereCV) {
boundingSphereCV = BoundingSphere.unpack(packedGeometry, packedGeometryIndex);
}
packedGeometryIndex += BoundingSphere.packedLength;
var length;
var values;
var componentsPerAttribute;
var attributes = new GeometryAttributes();
var numAttributes = packedGeometry[packedGeometryIndex++];
for (i = 0; i < numAttributes; i++) {
var name = stringTable[packedGeometry[packedGeometryIndex++]];
var componentDatatype = packedGeometry[packedGeometryIndex++];
componentsPerAttribute = packedGeometry[packedGeometryIndex++];
var normalize = packedGeometry[packedGeometryIndex++] !== 0;
length = packedGeometry[packedGeometryIndex++];
values = ComponentDatatype.createTypedArray(componentDatatype, length);
for (var valuesIndex = 0; valuesIndex < length; valuesIndex++) {
values[valuesIndex] = packedGeometry[packedGeometryIndex++];
}
attributes[name] = new GeometryAttribute({
componentDatatype : componentDatatype,
componentsPerAttribute : componentsPerAttribute,
normalize : normalize,
values : values
});
}
var indices;
length = packedGeometry[packedGeometryIndex++];
if (length > 0) {
var numberOfVertices = values.length / componentsPerAttribute;
indices = IndexDatatype.createTypedArray(numberOfVertices, length);
for (i = 0; i < length; i++) {
indices[i] = packedGeometry[packedGeometryIndex++];
}
}
result[resultIndex++] = new Geometry({
primitiveType : primitiveType,
geometryType : geometryType,
boundingSphere : boundingSphere,
boundingSphereCV : boundingSphereCV,
indices : indices,
attributes : attributes
});
}
return result;
};
function packInstancesForCombine(instances, transferableObjects) {
var length = instances.length;
var packedData = new Float64Array(1 + (length * 16));
var count = 0;
packedData[count++] = length;
for (var i = 0; i < length; i++) {
var instance = instances[i];
Matrix4.pack(instance.modelMatrix, packedData, count);
count += Matrix4.packedLength;
}
transferableObjects.push(packedData.buffer);
return packedData;
}
function unpackInstancesForCombine(data) {
var packedInstances = data;
var result = new Array(packedInstances[0]);
var count = 0;
var i = 1;
while (i < packedInstances.length) {
var modelMatrix = Matrix4.unpack(packedInstances, i);
i += Matrix4.packedLength;
result[count++] = {
modelMatrix : modelMatrix
};
}
return result;
}
/**
* @private
*/
PrimitivePipeline.packCombineGeometryParameters = function(parameters, transferableObjects) {
var createGeometryResults = parameters.createGeometryResults;
var length = createGeometryResults.length;
for (var i = 0; i < length; i++) {
transferableObjects.push(createGeometryResults[i].packedData.buffer);
}
return {
createGeometryResults : parameters.createGeometryResults,
packedInstances : packInstancesForCombine(parameters.instances, transferableObjects),
ellipsoid : parameters.ellipsoid,
isGeographic : parameters.projection instanceof GeographicProjection,
elementIndexUintSupported : parameters.elementIndexUintSupported,
scene3DOnly : parameters.scene3DOnly,
vertexCacheOptimize : parameters.vertexCacheOptimize,
compressVertices : parameters.compressVertices,
modelMatrix : parameters.modelMatrix,
createPickOffsets : parameters.createPickOffsets
};
};
/**
* @private
*/
PrimitivePipeline.unpackCombineGeometryParameters = function(packedParameters) {
var instances = unpackInstancesForCombine(packedParameters.packedInstances);
var createGeometryResults = packedParameters.createGeometryResults;
var length = createGeometryResults.length;
var instanceIndex = 0;
for (var resultIndex = 0; resultIndex < length; resultIndex++) {
var geometries = PrimitivePipeline.unpackCreateGeometryResults(createGeometryResults[resultIndex]);
var geometriesLength = geometries.length;
for (var geometryIndex = 0; geometryIndex < geometriesLength; geometryIndex++) {
var geometry = geometries[geometryIndex];
var instance = instances[instanceIndex];
instance.geometry = geometry;
++instanceIndex;
}
}
var ellipsoid = Ellipsoid.clone(packedParameters.ellipsoid);
var projection = packedParameters.isGeographic ? new GeographicProjection(ellipsoid) : new WebMercatorProjection(ellipsoid);
return {
instances : instances,
ellipsoid : ellipsoid,
projection : projection,
elementIndexUintSupported : packedParameters.elementIndexUintSupported,
scene3DOnly : packedParameters.scene3DOnly,
vertexCacheOptimize : packedParameters.vertexCacheOptimize,
compressVertices : packedParameters.compressVertices,
modelMatrix : Matrix4.clone(packedParameters.modelMatrix),
createPickOffsets : packedParameters.createPickOffsets
};
};
function packBoundingSpheres(boundingSpheres) {
var length = boundingSpheres.length;
var bufferLength = 1 + (BoundingSphere.packedLength + 1) * length;
var buffer = new Float32Array(bufferLength);
var bufferIndex = 0;
buffer[bufferIndex++] = length;
for (var i = 0; i < length; ++i) {
var bs = boundingSpheres[i];
if (!defined(bs)) {
buffer[bufferIndex++] = 0.0;
} else {
buffer[bufferIndex++] = 1.0;
BoundingSphere.pack(boundingSpheres[i], buffer, bufferIndex);
}
bufferIndex += BoundingSphere.packedLength;
}
return buffer;
}
function unpackBoundingSpheres(buffer) {
var result = new Array(buffer[0]);
var count = 0;
var i = 1;
while (i < buffer.length) {
if (buffer[i++] === 1.0) {
result[count] = BoundingSphere.unpack(buffer, i);
}
++count;
i += BoundingSphere.packedLength;
}
return result;
}
/**
* @private
*/
PrimitivePipeline.packCombineGeometryResults = function(results, transferableObjects) {
if (defined(results.geometries)) {
transferGeometries(results.geometries, transferableObjects);
}
var packedBoundingSpheres = packBoundingSpheres(results.boundingSpheres);
var packedBoundingSpheresCV = packBoundingSpheres(results.boundingSpheresCV);
transferableObjects.push(packedBoundingSpheres.buffer, packedBoundingSpheresCV.buffer);
return {
geometries : results.geometries,
attributeLocations : results.attributeLocations,
modelMatrix : results.modelMatrix,
pickOffsets : results.pickOffsets,
boundingSpheres : packedBoundingSpheres,
boundingSpheresCV : packedBoundingSpheresCV
};
};
/**
* @private
*/
PrimitivePipeline.unpackCombineGeometryResults = function(packedResult) {
return {
geometries : packedResult.geometries,
attributeLocations : packedResult.attributeLocations,
modelMatrix : packedResult.modelMatrix,
pickOffsets : packedResult.pickOffsets,
boundingSpheres : unpackBoundingSpheres(packedResult.boundingSpheres),
boundingSpheresCV : unpackBoundingSpheres(packedResult.boundingSpheresCV)
};
};
return PrimitivePipeline;
});
/*global define*/
define('Core/formatError',[
'./defined'
], function(
defined) {
'use strict';
/**
* Formats an error object into a String. If available, uses name, message, and stack
* properties, otherwise, falls back on toString().
*
* @exports formatError
*
* @param {Object} object The item to find in the array.
* @returns {String} A string containing the formatted error.
*/
function formatError(object) {
var result;
var name = object.name;
var message = object.message;
if (defined(name) && defined(message)) {
result = name + ': ' + message;
} else {
result = object.toString();
}
var stack = object.stack;
if (defined(stack)) {
result += '\n' + stack;
}
return result;
}
return formatError;
});
/*global define*/
define('Workers/createTaskProcessorWorker',[
'../Core/defaultValue',
'../Core/defined',
'../Core/formatError'
], function(
defaultValue,
defined,
formatError) {
'use strict';
/**
* Creates an adapter function to allow a calculation function to operate as a Web Worker,
* paired with TaskProcessor, to receive tasks and return results.
*
* @exports createTaskProcessorWorker
*
* @param {createTaskProcessorWorker~WorkerFunction} workerFunction The calculation function,
* which takes parameters and returns a result.
* @returns {createTaskProcessorWorker~TaskProcessorWorkerFunction} A function that adapts the
* calculation function to work as a Web Worker onmessage listener with TaskProcessor.
*
*
* @example
* function doCalculation(parameters, transferableObjects) {
* // calculate some result using the inputs in parameters
* return result;
* }
*
* return Cesium.createTaskProcessorWorker(doCalculation);
* // the resulting function is compatible with TaskProcessor
*
* @see TaskProcessor
* @see {@link http://www.w3.org/TR/workers/|Web Workers}
* @see {@link http://www.w3.org/TR/html5/common-dom-interfaces.html#transferable-objects|Transferable objects}
*/
function createTaskProcessorWorker(workerFunction) {
var postMessage;
var transferableObjects = [];
var responseMessage = {
id : undefined,
result : undefined,
error : undefined
};
return function(event) {
/*global self*/
var data = event.data;
transferableObjects.length = 0;
responseMessage.id = data.id;
responseMessage.error = undefined;
responseMessage.result = undefined;
try {
responseMessage.result = workerFunction(data.parameters, transferableObjects);
} catch (e) {
if (e instanceof Error) {
// Errors can't be posted in a message, copy the properties
responseMessage.error = {
name : e.name,
message : e.message,
stack : e.stack
};
} else {
responseMessage.error = e;
}
}
if (!defined(postMessage)) {
postMessage = defaultValue(self.webkitPostMessage, self.postMessage);
}
if (!data.canTransferArrayBuffer) {
transferableObjects.length = 0;
}
try {
postMessage(responseMessage, transferableObjects);
} catch (e) {
// something went wrong trying to post the message, post a simpler
// error that we can be sure will be cloneable
responseMessage.result = undefined;
responseMessage.error = 'postMessage failed with error: ' + formatError(e) + '\n with responseMessage: ' + JSON.stringify(responseMessage);
postMessage(responseMessage);
}
};
}
/**
* A function that performs a calculation in a Web Worker.
* @callback createTaskProcessorWorker~WorkerFunction
*
* @param {Object} parameters Parameters to the calculation.
* @param {Array} transferableObjects An array that should be filled with references to objects inside
* the result that should be transferred back to the main document instead of copied.
* @returns {Object} The result of the calculation.
*
* @example
* function calculate(parameters, transferableObjects) {
* // perform whatever calculation is necessary.
* var typedArray = new Float32Array(0);
*
* // typed arrays are transferable
* transferableObjects.push(typedArray)
*
* return {
* typedArray : typedArray
* };
* }
*/
/**
* A Web Worker message event handler function that handles the interaction with TaskProcessor,
* specifically, task ID management and posting a response message containing the result.
* @callback createTaskProcessorWorker~TaskProcessorWorkerFunction
*
* @param {Object} event The onmessage event object.
*/
return createTaskProcessorWorker;
});
/*global define*/
define('Workers/createGeometry',[
'../Core/defined',
'../Scene/PrimitivePipeline',
'./createTaskProcessorWorker',
'require'
], function(
defined,
PrimitivePipeline,
createTaskProcessorWorker,
require) {
'use strict';
var moduleCache = {};
function getModule(moduleName) {
var module = moduleCache[moduleName];
if (!defined(module)) {
if (typeof exports === 'object') {
// Use CommonJS-style require.
moduleCache[module] = module = require('Workers/' + moduleName);
} else {
// Use AMD-style require.
// in web workers, require is synchronous
require(['./' + moduleName], function(f) {
module = f;
moduleCache[module] = f;
});
}
}
return module;
}
function createGeometry(parameters, transferableObjects) {
var subTasks = parameters.subTasks;
var length = subTasks.length;
var results = new Array(length);
for (var i = 0; i < length; i++) {
var task = subTasks[i];
var geometry = task.geometry;
var moduleName = task.moduleName;
if (defined(moduleName)) {
var createFunction = getModule(moduleName);
results[i] = createFunction(geometry, task.offset);
} else {
//Already created geometry
results[i] = geometry;
}
}
return PrimitivePipeline.packCreateGeometryResults(results, transferableObjects);
}
return createTaskProcessorWorker(createGeometry);
});
}()); |
// Ion.RangeSlider | version 2.1.6 | https://github.com/IonDen/ion.rangeSlider
;(function(f){"function"===typeof define&&define.amd?define(["jquery"],function(p){return f(p,document,window,navigator)}):"object"===typeof exports?f(require("jquery"),document,window,navigator):f(jQuery,document,window,navigator)})(function(f,p,h,t,q){var u=0,m=function(){var a=t.userAgent,b=/msie\s\d+/i;return 0<a.search(b)&&(a=b.exec(a).toString(),a=a.split(" ")[1],9>a)?(f("html").addClass("lt-ie9"),!0):!1}();Function.prototype.bind||(Function.prototype.bind=function(a){var b=this,d=[].slice;if("function"!=
typeof b)throw new TypeError;var c=d.call(arguments,1),e=function(){if(this instanceof e){var g=function(){};g.prototype=b.prototype;var g=new g,l=b.apply(g,c.concat(d.call(arguments)));return Object(l)===l?l:g}return b.apply(a,c.concat(d.call(arguments)))};return e});Array.prototype.indexOf||(Array.prototype.indexOf=function(a,b){var d;if(null==this)throw new TypeError('"this" is null or not defined');var c=Object(this),e=c.length>>>0;if(0===e)return-1;d=+b||0;Infinity===Math.abs(d)&&(d=0);if(d>=
e)return-1;for(d=Math.max(0<=d?d:e-Math.abs(d),0);d<e;){if(d in c&&c[d]===a)return d;d++}return-1});var r=function(a,b,d){this.VERSION="2.1.6";this.input=a;this.plugin_count=d;this.old_to=this.old_from=this.update_tm=this.calc_count=this.current_plugin=0;this.raf_id=this.old_min_interval=null;this.is_update=this.is_key=this.no_diapason=this.force_redraw=this.dragging=!1;this.is_start=this.is_first_update=!0;this.is_click=this.is_resize=this.is_active=this.is_finish=!1;b=b||{};this.$cache={win:f(h),
body:f(p.body),input:f(a),cont:null,rs:null,min:null,max:null,from:null,to:null,single:null,bar:null,line:null,s_single:null,s_from:null,s_to:null,shad_single:null,shad_from:null,shad_to:null,edge:null,grid:null,grid_labels:[]};this.coords={x_gap:0,x_pointer:0,w_rs:0,w_rs_old:0,w_handle:0,p_gap:0,p_gap_left:0,p_gap_right:0,p_step:0,p_pointer:0,p_handle:0,p_single_fake:0,p_single_real:0,p_from_fake:0,p_from_real:0,p_to_fake:0,p_to_real:0,p_bar_x:0,p_bar_w:0,grid_gap:0,big_num:0,big:[],big_w:[],big_p:[],
big_x:[]};this.labels={w_min:0,w_max:0,w_from:0,w_to:0,w_single:0,p_min:0,p_max:0,p_from_fake:0,p_from_left:0,p_to_fake:0,p_to_left:0,p_single_fake:0,p_single_left:0};var c=this.$cache.input;a=c.prop("value");var e;d={type:"single",min:10,max:100,from:null,to:null,step:1,min_interval:0,max_interval:0,drag_interval:!1,values:[],p_values:[],from_fixed:!1,from_min:null,from_max:null,from_shadow:!1,to_fixed:!1,to_min:null,to_max:null,to_shadow:!1,prettify_enabled:!0,prettify_separator:" ",prettify:null,
force_edges:!1,keyboard:!1,keyboard_step:5,grid:!1,grid_margin:!0,grid_num:4,grid_snap:!1,hide_min_max:!1,hide_from_to:!1,prefix:"",postfix:"",max_postfix:"",decorate_both:!0,values_separator:" \u2014 ",input_values_separator:";",disable:!1,onStart:null,onChange:null,onFinish:null,onUpdate:null};"INPUT"!==c[0].nodeName&&console&&console.warn&&console.warn("Base element should be <input>!",c[0]);c={type:c.data("type"),min:c.data("min"),max:c.data("max"),from:c.data("from"),to:c.data("to"),step:c.data("step"),
min_interval:c.data("minInterval"),max_interval:c.data("maxInterval"),drag_interval:c.data("dragInterval"),values:c.data("values"),from_fixed:c.data("fromFixed"),from_min:c.data("fromMin"),from_max:c.data("fromMax"),from_shadow:c.data("fromShadow"),to_fixed:c.data("toFixed"),to_min:c.data("toMin"),to_max:c.data("toMax"),to_shadow:c.data("toShadow"),prettify_enabled:c.data("prettifyEnabled"),prettify_separator:c.data("prettifySeparator"),force_edges:c.data("forceEdges"),keyboard:c.data("keyboard"),
keyboard_step:c.data("keyboardStep"),grid:c.data("grid"),grid_margin:c.data("gridMargin"),grid_num:c.data("gridNum"),grid_snap:c.data("gridSnap"),hide_min_max:c.data("hideMinMax"),hide_from_to:c.data("hideFromTo"),prefix:c.data("prefix"),postfix:c.data("postfix"),max_postfix:c.data("maxPostfix"),decorate_both:c.data("decorateBoth"),values_separator:c.data("valuesSeparator"),input_values_separator:c.data("inputValuesSeparator"),disable:c.data("disable")};c.values=c.values&&c.values.split(",");for(e in c)c.hasOwnProperty(e)&&
(c[e]!==q&&""!==c[e]||delete c[e]);a!==q&&""!==a&&(a=a.split(c.input_values_separator||b.input_values_separator||";"),a[0]&&a[0]==+a[0]&&(a[0]=+a[0]),a[1]&&a[1]==+a[1]&&(a[1]=+a[1]),b&&b.values&&b.values.length?(d.from=a[0]&&b.values.indexOf(a[0]),d.to=a[1]&&b.values.indexOf(a[1])):(d.from=a[0]&&+a[0],d.to=a[1]&&+a[1]));f.extend(d,b);f.extend(d,c);this.options=d;this.update_check={};this.validate();this.result={input:this.$cache.input,slider:null,min:this.options.min,max:this.options.max,from:this.options.from,
from_percent:0,from_value:null,to:this.options.to,to_percent:0,to_value:null};this.init()};r.prototype={init:function(a){this.no_diapason=!1;this.coords.p_step=this.convertToPercent(this.options.step,!0);this.target="base";this.toggleInput();this.append();this.setMinMax();a?(this.force_redraw=!0,this.calc(!0),this.callOnUpdate()):(this.force_redraw=!0,this.calc(!0),this.callOnStart());this.updateScene()},append:function(){this.$cache.input.before('<span class="irs js-irs-'+this.plugin_count+'"></span>');
this.$cache.input.prop("readonly",!0);this.$cache.cont=this.$cache.input.prev();this.result.slider=this.$cache.cont;this.$cache.cont.html('<span class="irs"><span class="irs-line" tabindex="-1"><span class="irs-line-left"></span><span class="irs-line-mid"></span><span class="irs-line-right"></span></span><span class="irs-min">0</span><span class="irs-max">1</span><span class="irs-from">0</span><span class="irs-to">0</span><span class="irs-single">0</span></span><span class="irs-grid"></span><span class="irs-bar"></span>');
this.$cache.rs=this.$cache.cont.find(".irs");this.$cache.min=this.$cache.cont.find(".irs-min");this.$cache.max=this.$cache.cont.find(".irs-max");this.$cache.from=this.$cache.cont.find(".irs-from");this.$cache.to=this.$cache.cont.find(".irs-to");this.$cache.single=this.$cache.cont.find(".irs-single");this.$cache.bar=this.$cache.cont.find(".irs-bar");this.$cache.line=this.$cache.cont.find(".irs-line");this.$cache.grid=this.$cache.cont.find(".irs-grid");"single"===this.options.type?(this.$cache.cont.append('<span class="irs-bar-edge"></span><span class="irs-shadow shadow-single"></span><span class="irs-slider single"></span>'),
this.$cache.edge=this.$cache.cont.find(".irs-bar-edge"),this.$cache.s_single=this.$cache.cont.find(".single"),this.$cache.from[0].style.visibility="hidden",this.$cache.to[0].style.visibility="hidden",this.$cache.shad_single=this.$cache.cont.find(".shadow-single")):(this.$cache.cont.append('<span class="irs-shadow shadow-from"></span><span class="irs-shadow shadow-to"></span><span class="irs-slider from"></span><span class="irs-slider to"></span>'),this.$cache.s_from=this.$cache.cont.find(".from"),
this.$cache.s_to=this.$cache.cont.find(".to"),this.$cache.shad_from=this.$cache.cont.find(".shadow-from"),this.$cache.shad_to=this.$cache.cont.find(".shadow-to"),this.setTopHandler());this.options.hide_from_to&&(this.$cache.from[0].style.display="none",this.$cache.to[0].style.display="none",this.$cache.single[0].style.display="none");this.appendGrid();this.options.disable?(this.appendDisableMask(),this.$cache.input[0].disabled=!0):(this.$cache.cont.removeClass("irs-disabled"),this.$cache.input[0].disabled=
!1,this.bindEvents());this.options.drag_interval&&(this.$cache.bar[0].style.cursor="ew-resize")},setTopHandler:function(){var a=this.options.max,b=this.options.to;this.options.from>this.options.min&&b===a?this.$cache.s_from.addClass("type_last"):b<a&&this.$cache.s_to.addClass("type_last")},changeLevel:function(a){switch(a){case "single":this.coords.p_gap=this.toFixed(this.coords.p_pointer-this.coords.p_single_fake);break;case "from":this.coords.p_gap=this.toFixed(this.coords.p_pointer-this.coords.p_from_fake);
this.$cache.s_from.addClass("state_hover");this.$cache.s_from.addClass("type_last");this.$cache.s_to.removeClass("type_last");break;case "to":this.coords.p_gap=this.toFixed(this.coords.p_pointer-this.coords.p_to_fake);this.$cache.s_to.addClass("state_hover");this.$cache.s_to.addClass("type_last");this.$cache.s_from.removeClass("type_last");break;case "both":this.coords.p_gap_left=this.toFixed(this.coords.p_pointer-this.coords.p_from_fake),this.coords.p_gap_right=this.toFixed(this.coords.p_to_fake-
this.coords.p_pointer),this.$cache.s_to.removeClass("type_last"),this.$cache.s_from.removeClass("type_last")}},appendDisableMask:function(){this.$cache.cont.append('<span class="irs-disable-mask"></span>');this.$cache.cont.addClass("irs-disabled")},remove:function(){this.$cache.cont.remove();this.$cache.cont=null;this.$cache.line.off("keydown.irs_"+this.plugin_count);this.$cache.body.off("touchmove.irs_"+this.plugin_count);this.$cache.body.off("mousemove.irs_"+this.plugin_count);this.$cache.win.off("touchend.irs_"+
this.plugin_count);this.$cache.win.off("mouseup.irs_"+this.plugin_count);m&&(this.$cache.body.off("mouseup.irs_"+this.plugin_count),this.$cache.body.off("mouseleave.irs_"+this.plugin_count));this.$cache.grid_labels=[];this.coords.big=[];this.coords.big_w=[];this.coords.big_p=[];this.coords.big_x=[];cancelAnimationFrame(this.raf_id)},bindEvents:function(){if(!this.no_diapason){this.$cache.body.on("touchmove.irs_"+this.plugin_count,this.pointerMove.bind(this));this.$cache.body.on("mousemove.irs_"+this.plugin_count,
this.pointerMove.bind(this));this.$cache.win.on("touchend.irs_"+this.plugin_count,this.pointerUp.bind(this));this.$cache.win.on("mouseup.irs_"+this.plugin_count,this.pointerUp.bind(this));this.$cache.line.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click"));this.$cache.line.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click"));this.options.drag_interval&&"double"===this.options.type?(this.$cache.bar.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,
"both")),this.$cache.bar.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"both"))):(this.$cache.bar.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.bar.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")));"single"===this.options.type?(this.$cache.single.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"single")),this.$cache.s_single.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"single")),
this.$cache.shad_single.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.single.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"single")),this.$cache.s_single.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"single")),this.$cache.edge.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.shad_single.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click"))):(this.$cache.single.on("touchstart.irs_"+
this.plugin_count,this.pointerDown.bind(this,null)),this.$cache.single.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,null)),this.$cache.from.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.s_from.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.to.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"to")),this.$cache.s_to.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"to")),
this.$cache.shad_from.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.shad_to.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.from.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.s_from.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.to.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"to")),this.$cache.s_to.on("mousedown.irs_"+
this.plugin_count,this.pointerDown.bind(this,"to")),this.$cache.shad_from.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.shad_to.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")));if(this.options.keyboard)this.$cache.line.on("keydown.irs_"+this.plugin_count,this.key.bind(this,"keyboard"));m&&(this.$cache.body.on("mouseup.irs_"+this.plugin_count,this.pointerUp.bind(this)),this.$cache.body.on("mouseleave.irs_"+this.plugin_count,this.pointerUp.bind(this)))}},
pointerMove:function(a){this.dragging&&(this.coords.x_pointer=(a.pageX||a.originalEvent.touches&&a.originalEvent.touches[0].pageX)-this.coords.x_gap,this.calc())},pointerUp:function(a){this.current_plugin===this.plugin_count&&this.is_active&&(this.is_active=!1,this.$cache.cont.find(".state_hover").removeClass("state_hover"),this.force_redraw=!0,m&&f("*").prop("unselectable",!1),this.updateScene(),this.restoreOriginalMinInterval(),(f.contains(this.$cache.cont[0],a.target)||this.dragging)&&this.callOnFinish(),
this.dragging=!1)},pointerDown:function(a,b){b.preventDefault();var d=b.pageX||b.originalEvent.touches&&b.originalEvent.touches[0].pageX;2!==b.button&&("both"===a&&this.setTempMinInterval(),a||(a=this.target||"from"),this.current_plugin=this.plugin_count,this.target=a,this.dragging=this.is_active=!0,this.coords.x_gap=this.$cache.rs.offset().left,this.coords.x_pointer=d-this.coords.x_gap,this.calcPointerPercent(),this.changeLevel(a),m&&f("*").prop("unselectable",!0),this.$cache.line.trigger("focus"),
this.updateScene())},pointerClick:function(a,b){b.preventDefault();var d=b.pageX||b.originalEvent.touches&&b.originalEvent.touches[0].pageX;2!==b.button&&(this.current_plugin=this.plugin_count,this.target=a,this.is_click=!0,this.coords.x_gap=this.$cache.rs.offset().left,this.coords.x_pointer=+(d-this.coords.x_gap).toFixed(),this.force_redraw=!0,this.calc(),this.$cache.line.trigger("focus"))},key:function(a,b){if(!(this.current_plugin!==this.plugin_count||b.altKey||b.ctrlKey||b.shiftKey||b.metaKey)){switch(b.which){case 83:case 65:case 40:case 37:b.preventDefault();
this.moveByKey(!1);break;case 87:case 68:case 38:case 39:b.preventDefault(),this.moveByKey(!0)}return!0}},moveByKey:function(a){var b=this.coords.p_pointer,b=a?b+this.options.keyboard_step:b-this.options.keyboard_step;this.coords.x_pointer=this.toFixed(this.coords.w_rs/100*b);this.is_key=!0;this.calc()},setMinMax:function(){this.options&&(this.options.hide_min_max?(this.$cache.min[0].style.display="none",this.$cache.max[0].style.display="none"):(this.options.values.length?(this.$cache.min.html(this.decorate(this.options.p_values[this.options.min])),
this.$cache.max.html(this.decorate(this.options.p_values[this.options.max]))):(this.$cache.min.html(this.decorate(this._prettify(this.options.min),this.options.min)),this.$cache.max.html(this.decorate(this._prettify(this.options.max),this.options.max))),this.labels.w_min=this.$cache.min.outerWidth(!1),this.labels.w_max=this.$cache.max.outerWidth(!1)))},setTempMinInterval:function(){var a=this.result.to-this.result.from;null===this.old_min_interval&&(this.old_min_interval=this.options.min_interval);
this.options.min_interval=a},restoreOriginalMinInterval:function(){null!==this.old_min_interval&&(this.options.min_interval=this.old_min_interval,this.old_min_interval=null)},calc:function(a){if(this.options){this.calc_count++;if(10===this.calc_count||a)this.calc_count=0,this.coords.w_rs=this.$cache.rs.outerWidth(!1),this.calcHandlePercent();if(this.coords.w_rs){this.calcPointerPercent();a=this.getHandleX();"both"===this.target&&(this.coords.p_gap=0,a=this.getHandleX());"click"===this.target&&(this.coords.p_gap=
this.coords.p_handle/2,a=this.getHandleX(),this.target=this.options.drag_interval?"both_one":this.chooseHandle(a));switch(this.target){case "base":var b=(this.options.max-this.options.min)/100;a=(this.result.from-this.options.min)/b;b=(this.result.to-this.options.min)/b;this.coords.p_single_real=this.toFixed(a);this.coords.p_from_real=this.toFixed(a);this.coords.p_to_real=this.toFixed(b);this.coords.p_single_real=this.checkDiapason(this.coords.p_single_real,this.options.from_min,this.options.from_max);
this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,this.options.from_min,this.options.from_max);this.coords.p_to_real=this.checkDiapason(this.coords.p_to_real,this.options.to_min,this.options.to_max);this.coords.p_single_fake=this.convertToFakePercent(this.coords.p_single_real);this.coords.p_from_fake=this.convertToFakePercent(this.coords.p_from_real);this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real);this.target=null;break;case "single":if(this.options.from_fixed)break;
this.coords.p_single_real=this.convertToRealPercent(a);this.coords.p_single_real=this.calcWithStep(this.coords.p_single_real);this.coords.p_single_real=this.checkDiapason(this.coords.p_single_real,this.options.from_min,this.options.from_max);this.coords.p_single_fake=this.convertToFakePercent(this.coords.p_single_real);break;case "from":if(this.options.from_fixed)break;this.coords.p_from_real=this.convertToRealPercent(a);this.coords.p_from_real=this.calcWithStep(this.coords.p_from_real);this.coords.p_from_real>
this.coords.p_to_real&&(this.coords.p_from_real=this.coords.p_to_real);this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,this.options.from_min,this.options.from_max);this.coords.p_from_real=this.checkMinInterval(this.coords.p_from_real,this.coords.p_to_real,"from");this.coords.p_from_real=this.checkMaxInterval(this.coords.p_from_real,this.coords.p_to_real,"from");this.coords.p_from_fake=this.convertToFakePercent(this.coords.p_from_real);break;case "to":if(this.options.to_fixed)break;
this.coords.p_to_real=this.convertToRealPercent(a);this.coords.p_to_real=this.calcWithStep(this.coords.p_to_real);this.coords.p_to_real<this.coords.p_from_real&&(this.coords.p_to_real=this.coords.p_from_real);this.coords.p_to_real=this.checkDiapason(this.coords.p_to_real,this.options.to_min,this.options.to_max);this.coords.p_to_real=this.checkMinInterval(this.coords.p_to_real,this.coords.p_from_real,"to");this.coords.p_to_real=this.checkMaxInterval(this.coords.p_to_real,this.coords.p_from_real,"to");
this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real);break;case "both":if(this.options.from_fixed||this.options.to_fixed)break;a=this.toFixed(a+.001*this.coords.p_handle);this.coords.p_from_real=this.convertToRealPercent(a)-this.coords.p_gap_left;this.coords.p_from_real=this.calcWithStep(this.coords.p_from_real);this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,this.options.from_min,this.options.from_max);this.coords.p_from_real=this.checkMinInterval(this.coords.p_from_real,
this.coords.p_to_real,"from");this.coords.p_from_fake=this.convertToFakePercent(this.coords.p_from_real);this.coords.p_to_real=this.convertToRealPercent(a)+this.coords.p_gap_right;this.coords.p_to_real=this.calcWithStep(this.coords.p_to_real);this.coords.p_to_real=this.checkDiapason(this.coords.p_to_real,this.options.to_min,this.options.to_max);this.coords.p_to_real=this.checkMinInterval(this.coords.p_to_real,this.coords.p_from_real,"to");this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real);
break;case "both_one":if(!this.options.from_fixed&&!this.options.to_fixed){var d=this.convertToRealPercent(a);a=this.result.to_percent-this.result.from_percent;var c=a/2,b=d-c,d=d+c;0>b&&(b=0,d=b+a);100<d&&(d=100,b=d-a);this.coords.p_from_real=this.calcWithStep(b);this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,this.options.from_min,this.options.from_max);this.coords.p_from_fake=this.convertToFakePercent(this.coords.p_from_real);this.coords.p_to_real=this.calcWithStep(d);this.coords.p_to_real=
this.checkDiapason(this.coords.p_to_real,this.options.to_min,this.options.to_max);this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real)}}"single"===this.options.type?(this.coords.p_bar_x=this.coords.p_handle/2,this.coords.p_bar_w=this.coords.p_single_fake,this.result.from_percent=this.coords.p_single_real,this.result.from=this.convertToValue(this.coords.p_single_real),this.options.values.length&&(this.result.from_value=this.options.values[this.result.from])):(this.coords.p_bar_x=
this.toFixed(this.coords.p_from_fake+this.coords.p_handle/2),this.coords.p_bar_w=this.toFixed(this.coords.p_to_fake-this.coords.p_from_fake),this.result.from_percent=this.coords.p_from_real,this.result.from=this.convertToValue(this.coords.p_from_real),this.result.to_percent=this.coords.p_to_real,this.result.to=this.convertToValue(this.coords.p_to_real),this.options.values.length&&(this.result.from_value=this.options.values[this.result.from],this.result.to_value=this.options.values[this.result.to]));
this.calcMinMax();this.calcLabels()}}},calcPointerPercent:function(){this.coords.w_rs?(0>this.coords.x_pointer||isNaN(this.coords.x_pointer)?this.coords.x_pointer=0:this.coords.x_pointer>this.coords.w_rs&&(this.coords.x_pointer=this.coords.w_rs),this.coords.p_pointer=this.toFixed(this.coords.x_pointer/this.coords.w_rs*100)):this.coords.p_pointer=0},convertToRealPercent:function(a){return a/(100-this.coords.p_handle)*100},convertToFakePercent:function(a){return a/100*(100-this.coords.p_handle)},getHandleX:function(){var a=
100-this.coords.p_handle,b=this.toFixed(this.coords.p_pointer-this.coords.p_gap);0>b?b=0:b>a&&(b=a);return b},calcHandlePercent:function(){this.coords.w_handle="single"===this.options.type?this.$cache.s_single.outerWidth(!1):this.$cache.s_from.outerWidth(!1);this.coords.p_handle=this.toFixed(this.coords.w_handle/this.coords.w_rs*100)},chooseHandle:function(a){return"single"===this.options.type?"single":a>=this.coords.p_from_real+(this.coords.p_to_real-this.coords.p_from_real)/2?this.options.to_fixed?
"from":"to":this.options.from_fixed?"to":"from"},calcMinMax:function(){this.coords.w_rs&&(this.labels.p_min=this.labels.w_min/this.coords.w_rs*100,this.labels.p_max=this.labels.w_max/this.coords.w_rs*100)},calcLabels:function(){this.coords.w_rs&&!this.options.hide_from_to&&("single"===this.options.type?(this.labels.w_single=this.$cache.single.outerWidth(!1),this.labels.p_single_fake=this.labels.w_single/this.coords.w_rs*100,this.labels.p_single_left=this.coords.p_single_fake+this.coords.p_handle/
2-this.labels.p_single_fake/2):(this.labels.w_from=this.$cache.from.outerWidth(!1),this.labels.p_from_fake=this.labels.w_from/this.coords.w_rs*100,this.labels.p_from_left=this.coords.p_from_fake+this.coords.p_handle/2-this.labels.p_from_fake/2,this.labels.p_from_left=this.toFixed(this.labels.p_from_left),this.labels.p_from_left=this.checkEdges(this.labels.p_from_left,this.labels.p_from_fake),this.labels.w_to=this.$cache.to.outerWidth(!1),this.labels.p_to_fake=this.labels.w_to/this.coords.w_rs*100,
this.labels.p_to_left=this.coords.p_to_fake+this.coords.p_handle/2-this.labels.p_to_fake/2,this.labels.p_to_left=this.toFixed(this.labels.p_to_left),this.labels.p_to_left=this.checkEdges(this.labels.p_to_left,this.labels.p_to_fake),this.labels.w_single=this.$cache.single.outerWidth(!1),this.labels.p_single_fake=this.labels.w_single/this.coords.w_rs*100,this.labels.p_single_left=(this.labels.p_from_left+this.labels.p_to_left+this.labels.p_to_fake)/2-this.labels.p_single_fake/2,this.labels.p_single_left=
this.toFixed(this.labels.p_single_left)),this.labels.p_single_left=this.checkEdges(this.labels.p_single_left,this.labels.p_single_fake))},updateScene:function(){this.raf_id&&(cancelAnimationFrame(this.raf_id),this.raf_id=null);clearTimeout(this.update_tm);this.update_tm=null;this.options&&(this.drawHandles(),this.is_active?this.raf_id=requestAnimationFrame(this.updateScene.bind(this)):this.update_tm=setTimeout(this.updateScene.bind(this),300))},drawHandles:function(){this.coords.w_rs=this.$cache.rs.outerWidth(!1);
if(this.coords.w_rs){this.coords.w_rs!==this.coords.w_rs_old&&(this.target="base",this.is_resize=!0);if(this.coords.w_rs!==this.coords.w_rs_old||this.force_redraw)this.setMinMax(),this.calc(!0),this.drawLabels(),this.options.grid&&(this.calcGridMargin(),this.calcGridLabels()),this.force_redraw=!0,this.coords.w_rs_old=this.coords.w_rs,this.drawShadow();if(this.coords.w_rs&&(this.dragging||this.force_redraw||this.is_key)){if(this.old_from!==this.result.from||this.old_to!==this.result.to||this.force_redraw||
this.is_key){this.drawLabels();this.$cache.bar[0].style.left=this.coords.p_bar_x+"%";this.$cache.bar[0].style.width=this.coords.p_bar_w+"%";if("single"===this.options.type)this.$cache.s_single[0].style.left=this.coords.p_single_fake+"%";else{this.$cache.s_from[0].style.left=this.coords.p_from_fake+"%";this.$cache.s_to[0].style.left=this.coords.p_to_fake+"%";if(this.old_from!==this.result.from||this.force_redraw)this.$cache.from[0].style.left=this.labels.p_from_left+"%";if(this.old_to!==this.result.to||
this.force_redraw)this.$cache.to[0].style.left=this.labels.p_to_left+"%"}this.$cache.single[0].style.left=this.labels.p_single_left+"%";this.writeToInput();this.old_from===this.result.from&&this.old_to===this.result.to||this.is_start||(this.$cache.input.trigger("change"),this.$cache.input.trigger("input"));this.old_from=this.result.from;this.old_to=this.result.to;this.is_resize||this.is_update||this.is_start||this.is_finish||this.callOnChange();if(this.is_key||this.is_click||this.is_first_update)this.is_first_update=
this.is_click=this.is_key=!1,this.callOnFinish();this.is_finish=this.is_resize=this.is_update=!1}this.force_redraw=this.is_click=this.is_key=this.is_start=!1}}},drawLabels:function(){if(this.options){var a=this.options.values.length,b=this.options.p_values,d;if(!this.options.hide_from_to)if("single"===this.options.type)a=a?this.decorate(b[this.result.from]):this.decorate(this._prettify(this.result.from),this.result.from),this.$cache.single.html(a),this.calcLabels(),this.$cache.min[0].style.visibility=
this.labels.p_single_left<this.labels.p_min+1?"hidden":"visible",this.$cache.max[0].style.visibility=this.labels.p_single_left+this.labels.p_single_fake>100-this.labels.p_max-1?"hidden":"visible";else{a?(this.options.decorate_both?(a=this.decorate(b[this.result.from]),a+=this.options.values_separator,a+=this.decorate(b[this.result.to])):a=this.decorate(b[this.result.from]+this.options.values_separator+b[this.result.to]),d=this.decorate(b[this.result.from]),b=this.decorate(b[this.result.to])):(this.options.decorate_both?
(a=this.decorate(this._prettify(this.result.from),this.result.from),a+=this.options.values_separator,a+=this.decorate(this._prettify(this.result.to),this.result.to)):a=this.decorate(this._prettify(this.result.from)+this.options.values_separator+this._prettify(this.result.to),this.result.to),d=this.decorate(this._prettify(this.result.from),this.result.from),b=this.decorate(this._prettify(this.result.to),this.result.to));this.$cache.single.html(a);this.$cache.from.html(d);this.$cache.to.html(b);this.calcLabels();
b=Math.min(this.labels.p_single_left,this.labels.p_from_left);a=this.labels.p_single_left+this.labels.p_single_fake;d=this.labels.p_to_left+this.labels.p_to_fake;var c=Math.max(a,d);this.labels.p_from_left+this.labels.p_from_fake>=this.labels.p_to_left?(this.$cache.from[0].style.visibility="hidden",this.$cache.to[0].style.visibility="hidden",this.$cache.single[0].style.visibility="visible",this.result.from===this.result.to?("from"===this.target?this.$cache.from[0].style.visibility="visible":"to"===
this.target?this.$cache.to[0].style.visibility="visible":this.target||(this.$cache.from[0].style.visibility="visible"),this.$cache.single[0].style.visibility="hidden",c=d):(this.$cache.from[0].style.visibility="hidden",this.$cache.to[0].style.visibility="hidden",this.$cache.single[0].style.visibility="visible",c=Math.max(a,d))):(this.$cache.from[0].style.visibility="visible",this.$cache.to[0].style.visibility="visible",this.$cache.single[0].style.visibility="hidden");this.$cache.min[0].style.visibility=
b<this.labels.p_min+1?"hidden":"visible";this.$cache.max[0].style.visibility=c>100-this.labels.p_max-1?"hidden":"visible"}}},drawShadow:function(){var a=this.options,b=this.$cache,d="number"===typeof a.from_min&&!isNaN(a.from_min),c="number"===typeof a.from_max&&!isNaN(a.from_max),e="number"===typeof a.to_min&&!isNaN(a.to_min),g="number"===typeof a.to_max&&!isNaN(a.to_max);"single"===a.type?a.from_shadow&&(d||c)?(d=this.convertToPercent(d?a.from_min:a.min),c=this.convertToPercent(c?a.from_max:a.max)-
d,d=this.toFixed(d-this.coords.p_handle/100*d),c=this.toFixed(c-this.coords.p_handle/100*c),d+=this.coords.p_handle/2,b.shad_single[0].style.display="block",b.shad_single[0].style.left=d+"%",b.shad_single[0].style.width=c+"%"):b.shad_single[0].style.display="none":(a.from_shadow&&(d||c)?(d=this.convertToPercent(d?a.from_min:a.min),c=this.convertToPercent(c?a.from_max:a.max)-d,d=this.toFixed(d-this.coords.p_handle/100*d),c=this.toFixed(c-this.coords.p_handle/100*c),d+=this.coords.p_handle/2,b.shad_from[0].style.display=
"block",b.shad_from[0].style.left=d+"%",b.shad_from[0].style.width=c+"%"):b.shad_from[0].style.display="none",a.to_shadow&&(e||g)?(e=this.convertToPercent(e?a.to_min:a.min),a=this.convertToPercent(g?a.to_max:a.max)-e,e=this.toFixed(e-this.coords.p_handle/100*e),a=this.toFixed(a-this.coords.p_handle/100*a),e+=this.coords.p_handle/2,b.shad_to[0].style.display="block",b.shad_to[0].style.left=e+"%",b.shad_to[0].style.width=a+"%"):b.shad_to[0].style.display="none")},writeToInput:function(){"single"===
this.options.type?(this.options.values.length?this.$cache.input.prop("value",this.result.from_value):this.$cache.input.prop("value",this.result.from),this.$cache.input.data("from",this.result.from)):(this.options.values.length?this.$cache.input.prop("value",this.result.from_value+this.options.input_values_separator+this.result.to_value):this.$cache.input.prop("value",this.result.from+this.options.input_values_separator+this.result.to),this.$cache.input.data("from",this.result.from),this.$cache.input.data("to",
this.result.to))},callOnStart:function(){this.writeToInput();if(this.options.onStart&&"function"===typeof this.options.onStart)this.options.onStart(this.result)},callOnChange:function(){this.writeToInput();if(this.options.onChange&&"function"===typeof this.options.onChange)this.options.onChange(this.result)},callOnFinish:function(){this.writeToInput();if(this.options.onFinish&&"function"===typeof this.options.onFinish)this.options.onFinish(this.result)},callOnUpdate:function(){this.writeToInput();
if(this.options.onUpdate&&"function"===typeof this.options.onUpdate)this.options.onUpdate(this.result)},toggleInput:function(){this.$cache.input.toggleClass("irs-hidden-input")},convertToPercent:function(a,b){var d=this.options.max-this.options.min;return d?this.toFixed((b?a:a-this.options.min)/(d/100)):(this.no_diapason=!0,0)},convertToValue:function(a){var b=this.options.min,d=this.options.max,c=b.toString().split(".")[1],e=d.toString().split(".")[1],g,l,f=0,k=0;if(0===a)return this.options.min;
if(100===a)return this.options.max;c&&(f=g=c.length);e&&(f=l=e.length);g&&l&&(f=g>=l?g:l);0>b&&(k=Math.abs(b),b=+(b+k).toFixed(f),d=+(d+k).toFixed(f));a=(d-b)/100*a+b;(b=this.options.step.toString().split(".")[1])?a=+a.toFixed(b.length):(a/=this.options.step,a*=this.options.step,a=+a.toFixed(0));k&&(a-=k);k=b?+a.toFixed(b.length):this.toFixed(a);k<this.options.min?k=this.options.min:k>this.options.max&&(k=this.options.max);return k},calcWithStep:function(a){var b=Math.round(a/this.coords.p_step)*
this.coords.p_step;100<b&&(b=100);100===a&&(b=100);return this.toFixed(b)},checkMinInterval:function(a,b,d){var c=this.options;if(!c.min_interval)return a;a=this.convertToValue(a);b=this.convertToValue(b);"from"===d?b-a<c.min_interval&&(a=b-c.min_interval):a-b<c.min_interval&&(a=b+c.min_interval);return this.convertToPercent(a)},checkMaxInterval:function(a,b,d){var c=this.options;if(!c.max_interval)return a;a=this.convertToValue(a);b=this.convertToValue(b);"from"===d?b-a>c.max_interval&&(a=b-c.max_interval):
a-b>c.max_interval&&(a=b+c.max_interval);return this.convertToPercent(a)},checkDiapason:function(a,b,d){a=this.convertToValue(a);var c=this.options;"number"!==typeof b&&(b=c.min);"number"!==typeof d&&(d=c.max);a<b&&(a=b);a>d&&(a=d);return this.convertToPercent(a)},toFixed:function(a){a=a.toFixed(20);return+a},_prettify:function(a){return this.options.prettify_enabled?this.options.prettify&&"function"===typeof this.options.prettify?this.options.prettify(a):this.prettify(a):a},prettify:function(a){return a.toString().replace(/(\d{1,3}(?=(?:\d\d\d)+(?!\d)))/g,
"$1"+this.options.prettify_separator)},checkEdges:function(a,b){if(!this.options.force_edges)return this.toFixed(a);0>a?a=0:a>100-b&&(a=100-b);return this.toFixed(a)},validate:function(){var a=this.options,b=this.result,d=a.values,c=d.length,e,g;"string"===typeof a.min&&(a.min=+a.min);"string"===typeof a.max&&(a.max=+a.max);"string"===typeof a.from&&(a.from=+a.from);"string"===typeof a.to&&(a.to=+a.to);"string"===typeof a.step&&(a.step=+a.step);"string"===typeof a.from_min&&(a.from_min=+a.from_min);
"string"===typeof a.from_max&&(a.from_max=+a.from_max);"string"===typeof a.to_min&&(a.to_min=+a.to_min);"string"===typeof a.to_max&&(a.to_max=+a.to_max);"string"===typeof a.keyboard_step&&(a.keyboard_step=+a.keyboard_step);"string"===typeof a.grid_num&&(a.grid_num=+a.grid_num);a.max<a.min&&(a.max=a.min);if(c)for(a.p_values=[],a.min=0,a.max=c-1,a.grid_num=(a.grid_num!=4?a.grid_num:a.max),/*a.step=1,a.grid_num=a.max,a.grid_snap=!0,*/g=0;g<c;g++)e=+d[g],isNaN(e)?e=d[g]:(d[g]=e,e=this._prettify(e)),a.p_values.push(e);if("number"!==typeof a.from||isNaN(a.from))a.from=
a.min;if("number"!==typeof a.to||isNaN(a.to))a.to=a.max;"single"===a.type?(a.from<a.min&&(a.from=a.min),a.from>a.max&&(a.from=a.max)):(a.from<a.min&&(a.from=a.min),a.from>a.max&&(a.from=a.max),a.to<a.min&&(a.to=a.min),a.to>a.max&&(a.to=a.max),this.update_check.from&&(this.update_check.from!==a.from&&a.from>a.to&&(a.from=a.to),this.update_check.to!==a.to&&a.to<a.from&&(a.to=a.from)),a.from>a.to&&(a.from=a.to),a.to<a.from&&(a.to=a.from));if("number"!==typeof a.step||isNaN(a.step)||!a.step||0>a.step)a.step=
1;if("number"!==typeof a.keyboard_step||isNaN(a.keyboard_step)||!a.keyboard_step||0>a.keyboard_step)a.keyboard_step=5;"number"===typeof a.from_min&&a.from<a.from_min&&(a.from=a.from_min);"number"===typeof a.from_max&&a.from>a.from_max&&(a.from=a.from_max);"number"===typeof a.to_min&&a.to<a.to_min&&(a.to=a.to_min);"number"===typeof a.to_max&&a.from>a.to_max&&(a.to=a.to_max);if(b){b.min!==a.min&&(b.min=a.min);b.max!==a.max&&(b.max=a.max);if(b.from<b.min||b.from>b.max)b.from=a.from;if(b.to<b.min||b.to>
b.max)b.to=a.to}if("number"!==typeof a.min_interval||isNaN(a.min_interval)||!a.min_interval||0>a.min_interval)a.min_interval=0;if("number"!==typeof a.max_interval||isNaN(a.max_interval)||!a.max_interval||0>a.max_interval)a.max_interval=0;a.min_interval&&a.min_interval>a.max-a.min&&(a.min_interval=a.max-a.min);a.max_interval&&a.max_interval>a.max-a.min&&(a.max_interval=a.max-a.min)},decorate:function(a,b){var d="",c=this.options;c.prefix&&(d+=c.prefix);d+=a;c.max_postfix&&(c.values.length&&a===c.p_values[c.max]?
(d+=c.max_postfix,c.postfix&&(d+=" ")):b===c.max&&(d+=c.max_postfix,c.postfix&&(d+=" ")));c.postfix&&(d+=c.postfix);return d},updateFrom:function(){this.result.from=this.options.from;this.result.from_percent=this.convertToPercent(this.result.from);this.options.values&&(this.result.from_value=this.options.values[this.result.from])},updateTo:function(){this.result.to=this.options.to;this.result.to_percent=this.convertToPercent(this.result.to);this.options.values&&(this.result.to_value=this.options.values[this.result.to])},
updateResult:function(){this.result.min=this.options.min;this.result.max=this.options.max;this.updateFrom();this.updateTo()},appendGrid:function(){if(this.options.grid){var a=this.options,b,d;b=a.max-a.min;var c=a.grid_num,e,g,f=4,h,k,m,n="";this.calcGridMargin();a.grid_snap?(c=b/a.step,e=this.toFixed(a.step/(b/100))):e=this.toFixed(100/c);4<c&&(f=3);7<c&&(f=2);14<c&&(f=1);28<c&&(f=0);for(b=0;b<c+1;b++){h=f;g=this.toFixed(e*b);100<g&&(g=100,h-=2,0>h&&(h=0));this.coords.big[b]=g;k=(g-e*(b-1))/(h+1);
for(d=1;d<=h&&0!==g;d++)m=this.toFixed(g-k*d),n+='<span class="irs-grid-pol small" style="left: '+m+'%"></span>';n+='<span class="irs-grid-pol" style="left: '+g+'%"></span>';d=this.convertToValue(g);d=a.values.length?a.p_values[d]:this._prettify(d);n+='<span class="irs-grid-text js-grid-text-'+b+'" style="left: '+g+'%">'+d+"</span>"}this.coords.big_num=Math.ceil(c+1);this.$cache.cont.addClass("irs-with-grid");this.$cache.grid.html(n);this.cacheGridLabels()}},cacheGridLabels:function(){var a,b,d=this.coords.big_num;
for(b=0;b<d;b++)a=this.$cache.grid.find(".js-grid-text-"+b),this.$cache.grid_labels.push(a);this.calcGridLabels()},calcGridLabels:function(){var a,b;b=[];var d=[],c=this.coords.big_num;for(a=0;a<c;a++)this.coords.big_w[a]=this.$cache.grid_labels[a].outerWidth(!1),this.coords.big_p[a]=this.toFixed(this.coords.big_w[a]/this.coords.w_rs*100),this.coords.big_x[a]=this.toFixed(this.coords.big_p[a]/2),b[a]=this.toFixed(this.coords.big[a]-this.coords.big_x[a]),d[a]=this.toFixed(b[a]+this.coords.big_p[a]);
this.options.force_edges&&(b[0]<-this.coords.grid_gap&&(b[0]=-this.coords.grid_gap,d[0]=this.toFixed(b[0]+this.coords.big_p[0]),this.coords.big_x[0]=this.coords.grid_gap),d[c-1]>100+this.coords.grid_gap&&(d[c-1]=100+this.coords.grid_gap,b[c-1]=this.toFixed(d[c-1]-this.coords.big_p[c-1]),this.coords.big_x[c-1]=this.toFixed(this.coords.big_p[c-1]-this.coords.grid_gap)));this.calcGridCollision(2,b,d);this.calcGridCollision(4,b,d);for(a=0;a<c;a++)b=this.$cache.grid_labels[a][0],this.coords.big_x[a]!==
Number.POSITIVE_INFINITY&&(b.style.marginLeft=-this.coords.big_x[a]+"%")},calcGridCollision:function(a,b,d){var c,e,g,f=this.coords.big_num;for(c=0;c<f;c+=a){e=c+a/2;if(e>=f)break;g=this.$cache.grid_labels[e][0];g.style.visibility=d[c]<=b[e]?"visible":"hidden"}},calcGridMargin:function(){this.options.grid_margin&&(this.coords.w_rs=this.$cache.rs.outerWidth(!1),this.coords.w_rs&&(this.coords.w_handle="single"===this.options.type?this.$cache.s_single.outerWidth(!1):this.$cache.s_from.outerWidth(!1),
this.coords.p_handle=this.toFixed(this.coords.w_handle/this.coords.w_rs*100),this.coords.grid_gap=this.toFixed(this.coords.p_handle/2-.1),this.$cache.grid[0].style.width=this.toFixed(100-this.coords.p_handle)+"%",this.$cache.grid[0].style.left=this.coords.grid_gap+"%"))},update:function(a){this.input&&(this.is_update=!0,this.options.from=this.result.from,this.options.to=this.result.to,this.update_check.from=this.result.from,this.update_check.to=this.result.to,this.options=f.extend(this.options,a),
this.validate(),this.updateResult(a),this.toggleInput(),this.remove(),this.init(!0))},reset:function(){this.input&&(this.updateResult(),this.update())},destroy:function(){this.input&&(this.toggleInput(),this.$cache.input.prop("readonly",!1),f.data(this.input,"ionRangeSlider",null),this.remove(),this.options=this.input=null)}};f.fn.ionRangeSlider=function(a){return this.each(function(){f.data(this,"ionRangeSlider")||f.data(this,"ionRangeSlider",new r(this,a,u++))})};(function(){for(var a=0,b=["ms",
"moz","webkit","o"],d=0;d<b.length&&!h.requestAnimationFrame;++d)h.requestAnimationFrame=h[b[d]+"RequestAnimationFrame"],h.cancelAnimationFrame=h[b[d]+"CancelAnimationFrame"]||h[b[d]+"CancelRequestAnimationFrame"];h.requestAnimationFrame||(h.requestAnimationFrame=function(b,d){var c=(new Date).getTime(),e=Math.max(0,16-(c-a)),f=h.setTimeout(function(){b(c+e)},e);a=c+e;return f});h.cancelAnimationFrame||(h.cancelAnimationFrame=function(a){clearTimeout(a)})})()}); |
module.exports = function (grunt) {
/** LOAD Tasks **/
grunt.loadNpmTasks('grunt-replace');
grunt.loadNpmTasks('grunt-bower-cli');
grunt.loadNpmTasks('grunt-contrib-clean');
grunt.loadNpmTasks('grunt-contrib-uglify');
grunt.loadNpmTasks('grunt-contrib-requirejs');
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.loadNpmTasks('grunt-contrib-concat');
grunt.loadNpmTasks('grunt-npm2bower-sync');
grunt.loadNpmTasks('grunt-docco');
// Project configuration.
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
clean: {
dist: ['./dist']
},
sync: {
all: {
options: {
sync: ['author', 'name', 'version', 'license', 'main', 'keywords'],
from: 'package.json',
to: 'bower.json'
}
}
},
docco: {
source: {
src: ['src/parsley.js', 'src/parsley/*.js', 'src/extra/plugin/remote.js'],
options: {
output: 'doc/annotated-source/',
layout: 'parallel'
}
}
},
replace: {
annotated: {
options: {
patterns: [
{
match: /<div id="jump_page">/ig,
replacement: function () {
return '<div id="jump_page"><a class="source" href="../index.html"><<< back to documentation</a>';
}
},
{
match: /<\/body>/ig,
replacement: function () {
return '<script type="text/javascript">var _gaq=_gaq||[];_gaq.push(["_setAccount","UA-37229467-1"]);_gaq.push(["_trackPageview"]);(function(){var e=document.createElement("script");e.type="text/javascript";e.async=true;e.src=("https:"==document.location.protocol?"https://ssl":"http://www")+".google-analytics.com/ga.js";var t=document.getElementsByTagName("script")[0];t.parentNode.insertBefore(e,t)})();</script></body>';
}
},
{
match: 'version',
replacement: '<%= pkg.version %>'
},
]
},
files: [
{
expand: true,
flatten: true,
src: 'doc/annotated-source/*.html',
dest: 'doc/annotated-source/'
}
]
},
dist: {
options: {
patterns: [
{
match: 'name',
replacement: '<%= pkg.name.charAt(0).toUpperCase() + pkg.name.slice(1) %>'
},
{
match: 'version',
replacement: '<%= pkg.version %>'
},
{
match: 'author',
replacement: '<%= pkg.author.name %> - <<%= pkg.author.email %>>'
},
{
match: 'timestamp',
replacement: '<%= grunt.template.today() %>'
},
{
match: 'license',
replacement: '<%= pkg.license %>'
},
// Remove useless define statements that r.js add after concatenation, and not matched by convert callback
{
match: /define\("((?!\);)[\s\S])*\);/ig,
replacement: function () {
return '';
}
},
// Remove useless double line breaks
{
match: /\n\n/ig,
replacement: function () {
return "\n";
}
}
]
},
files: [
{
expand: true,
flatten: true,
src: 'dist/parsley.js',
dest: 'dist/'
}
]
}
},
requirejs: {
compile: {
options: {
// name: "./bower_components/almond/almond",
name: "parsley",
mainConfigFile: "./src/config.js",
wrap: {
startFile: "src/wrap/prepend.js",
endFile: "src/wrap/append.js"
},
optimize: 'none',
out: "dist/parsley.js",
findNestedDependencies: true,
// Avoid breaking semicolons inserted by r.js
skipSemiColonInsertion: true,
onBuildWrite: convert
}
}
},
uglify: {
options: {
report: 'gzip',
preserveComments: function (pos, node) {
return new RegExp('^!').test(node.value) && RegExp('parsley', 'i').test(node.value);
}
},
min: {
files: {
'dist/parsley.min.js': 'dist/parsley.js'
}
},
remote: {
files: {
'dist/parsley.remote.min.js': 'dist/parsley.remote.js'
}
}
},
watch: {
dev: {
files: ['src/parsley.js', 'src/parsley.css', 'src/wrap/*.js', 'src/parsley/*.js'],
tasks: ['requirejs', 'replace:dist']
}
},
concat: {
remote: {
src: ['src/extra/plugin/remote.js', 'dist/parsley.js'],
dest: 'dist/parsley.remote.js'
}
}
});
/** Tasks here **/
grunt.registerTask('default', []);
grunt.registerTask('configure', ['bower:install']);
grunt.registerTask('build-std', ['requirejs', 'replace:dist', 'uglify:min']);
grunt.registerTask('build-remote', ['concat:remote', 'uglify:remote']);
grunt.registerTask('build-annotated-source', ['docco:source', 'replace:annotated']);
grunt.registerTask('build', ['configure', 'clean:dist', 'build-std', 'build-remote', 'build-annotated-source', 'sync']);
grunt.registerTask('build-all', ['build']);
};
var rdefineEnd = /\}\);[^}\w]*$/;
function convert(name, path, contents) {
// Update original validatorjs for non-AMD implementation
if (/(dist\/validator.js)/.test(path)) {
// Makes sure the self-executing wrapper function stores a variable
contents = contents.replace("(","var Validator = (");
// Makes sure the self-executing wrapper function returns an object
var lastClosingBraceIndex = contents.lastIndexOf("}");
contents = contents.substring(0, lastClosingBraceIndex)
+ "\n\n return exports;\n}"
+ contents.substring(lastClosingBraceIndex + 1);
return contents;
}
// Ignore returns
contents = contents
.replace(/\s*return\s+[^\}]+(\}\);[^\w\}]*)$/, "$1")
// Multiple exports
.replace(/\s*exports\.\w+\s*=\s*\w+;/g, "");
// Remove define wrappers, closure ends, and empty declarations
contents = contents
.replace(/define\([^{]*?{/, "")
.replace(rdefineEnd, "\n");
return contents;
}
|
'use strict';
class Credits {
create() {
this.game.stage.backgroundColor = '#FFF';
var tmpCreditsText = this.game.cache.getImage('credits_text');
var credits_text = this.game.add.sprite(
(this.game.width - tmpCreditsText.width) / 2,
this.game.height * 0.2,
'credits_text'
);
var tmpCreditsDarwin = this.game.cache.getImage("credits_darwin");
var credits_darwin_x = 0.1 * this.game.width;
var credits_darwin_y = this.game.height - tmpCreditsDarwin.height - 0.1 * this.game.height;
var credits_darwin = this.game.add.sprite(credits_darwin_x, credits_darwin_y, "credits_darwin");
this.game.input.onDown.add(this.goMenu, this);
}
goMenu() {
this.game.state.start('menu');
}
}
export default Credits; |
import React, { PureComponent } from 'react'
import PropTypes from 'prop-types'
import { Text, View } from 'react-native'
import * as d3Scale from 'd3-scale'
import * as array from 'd3-array'
import Svg, { G, Text as SVGText } from 'react-native-svg'
class XAxis extends PureComponent {
state = {
width: 0,
height: 0,
}
_onLayout(event) {
const {
nativeEvent: {
layout: { width, height },
},
} = event
if (width !== this.state.width) {
this.setState({ width, height })
}
}
_getX(domain) {
const {
scale,
spacingInner,
spacingOuter,
contentInset: { left = 0, right = 0 },
} = this.props
const { width } = this.state
const x = scale()
.domain(domain)
.range([left, width - right])
if (scale === d3Scale.scaleBand) {
x.paddingInner([spacingInner]).paddingOuter([spacingOuter])
//add half a bar to center label
return (value) => x(value) + x.bandwidth() / 2
}
return x
}
render() {
const { style, scale, data, xAccessor, formatLabel, numberOfTicks, svg, children, min, max } = this.props
const { height, width } = this.state
if (data.length === 0) {
return <View style={style} />
}
const values = data.map((item, index) => xAccessor({ item, index }))
const extent = array.extent(values)
const domain = scale === d3Scale.scaleBand ? values : [min || extent[0], max || extent[1]]
const x = this._getX(domain)
const ticks = numberOfTicks ? x.ticks(numberOfTicks) : values
const extraProps = {
x,
ticks,
width,
height,
formatLabel,
}
return (
<View style={style}>
<View style={{ flexGrow: 1 }} onLayout={(event) => this._onLayout(event)}>
{/*invisible text to allow for parent resizing*/}
<Text
style={{
opacity: 0,
fontSize: svg.fontSize,
fontFamily: svg.fontFamily,
fontWeight: svg.fontWeight,
}}
>
{formatLabel(ticks[0], 0)}
</Text>
{height > 0 && width > 0 && (
<Svg
style={{
position: 'absolute',
top: 0,
left: 0,
height,
width,
}}
>
<G>
{React.Children.map(children, (child) => {
return React.cloneElement(child, extraProps)
})}
{// don't render labels if width isn't measured yet,
// causes rendering issues
width > 0 &&
ticks.map((value, index) => {
const { svg: valueSvg = {} } = data[index] || {}
return (
<SVGText
textAnchor={'middle'}
originX={x(value)}
alignmentBaseline={'hanging'}
{...svg}
{...valueSvg}
key={index}
x={x(value)}
>
{formatLabel(value, index)}
</SVGText>
)
})}
</G>
</Svg>
)}
</View>
</View>
)
}
}
XAxis.propTypes = {
data: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.number, PropTypes.object])).isRequired,
spacingInner: PropTypes.number,
spacingOuter: PropTypes.number,
formatLabel: PropTypes.func,
contentInset: PropTypes.shape({
left: PropTypes.number,
right: PropTypes.number,
}),
scale: PropTypes.func,
numberOfTicks: PropTypes.number,
xAccessor: PropTypes.func,
svg: PropTypes.object,
min: PropTypes.any,
max: PropTypes.any,
}
XAxis.defaultProps = {
spacingInner: 0.05,
spacingOuter: 0.05,
contentInset: {},
svg: {},
xAccessor: ({ index }) => index,
scale: d3Scale.scaleLinear,
formatLabel: (value) => value,
}
export default XAxis
|
var React = require('react');
var PropTypes = React.PropTypes;
function Main (props) {
return (
<div className="main-container">
{props.children}
</div>
);
}
module.exports = Main;
|
const webpack = require('webpack');
const postcssBasePlugins = [
// require('postcss-modules-local-by-default'),
require('postcss-import')({
addDependencyTo: webpack,
}),
require('postcss-cssnext')({
browsers: ['last 2 versions', 'Firefox ESR', '> 1%', 'ie >= 8'],
}),
];
const postcssDevPlugins = [];
const postcssProdPlugins = [
require('cssnano')({
safe: true,
sourcemap: true,
autoprefixer: false,
}),
];
const postcssPlugins = postcssBasePlugins
.concat(process.env.NODE_ENV === 'production' ? postcssProdPlugins : [])
.concat(process.env.NODE_ENV === 'development' ? postcssDevPlugins : []);
module.exports = () => {
return postcssPlugins;
};
|
/*!
* Angular Material Design
* https://github.com/angular/material
* @license MIT
* v0.10.1-master-76bc8b9
*/
!function(t,n,i){"use strict";n.module("material.components.backdrop",["material.core"]).directive("mdBackdrop",["$mdTheming","$animate","$rootElement","$window","$log","$$rAF","$document",function(t,n,i,e,o,r,a){function p(p,d,s){var m=e.getComputedStyle(a[0].body);if("fixed"==m.position){var l=parseInt(m.height,10)+Math.abs(parseInt(m.top,10));d.css({height:l+"px"})}n.pin&&n.pin(d,i),r(function(){var n=d.parent()[0];if(n){var i=e.getComputedStyle(n);"static"==i.position&&o.warn(c)}t.inherit(d,d.parent())})}var c="<md-backdrop> may not work properly in a scrolled, static-positioned parent container.";return{restrict:"E",link:p}}])}(window,window.angular); |
export class RoomDeleted {
constructor(room) {
this.room = room;
}
} |
(function(angular){
angular.module('app')
.controller('PlayerCtrl',
['$scope', '$game', '$socket', '$location',
function ($scope, $game, $socket, $location) {
$scope.$game = $game;
$scope.move = $game.move;
$scope.color = 'gray';
$scope.me = $game.me;
$scope.$watch('$game.me', function (me) {
if (me) {
$scope.me = me;
if (!me.handle) {
$location.url('/');
return;
}
$scope.color = me.color;
$scope.$watch('me.color', function (color) {
if (color) {
$scope.color = me.color;
}
});
$scope.$watch('me.playing', function (playing) {
if (!playing) {
$game.play();
}
});
}
});
$scope.$on('$destroy', function () {
$game.stopPlay();
});
}]);
}(angular)); |
var types = Ext.data.Types;
Ext.define('MilestoneTreeModel', {
extend: 'Ext.data.TreeModel',
fields: [
{name: 'FormattedID', mapping: 'FormattedID', type: types.STRING},
{name: 'Name', mapping: 'Name', type: types.STRING},
{name: 'TargetDate', mapping: 'AcceptedDate', type: types.DATE },
{name: 'TargetProject', mapping: 'TargetProject', type: types.OBJECT},
{name: 'ValueStream', mapping: 'ValueStream', type: types.STRING},
{name: 'Visibility', mapping: 'Visibility', type: types.STRING},
{name: 'Status', mapping: 'Status', type: types.STRING},
{name: 'DisplayColor', mapping: 'DisplayColor', type: types.STRING},
{name: 'Notes', mapping: 'Notes', type: types.STRING},
{name: '_ref', mapping: '_ref', type: types.STRING}
],
hasMany: {model: 'FeatureTreeModel', name:'features', associationKey: 'features'}
});
Ext.define('CustomApp', {
extend: 'Rally.app.App',
componentCls: 'app',
getSettingsFields: function() {
return [
{
name: 'executiveVisibilityOnly',
xtype: 'rallycheckboxfield',
fieldLabel: '',
boxLabel: 'Only show Milestones with Executive Visibility'
},
{
name: 'includeGlobalMilestones',
xtype: 'rallycheckboxfield',
fieldLabel: '',
boxLabel: 'Include global milestones'
},
{
name: 'showNumberOfMonths',
xtype: 'rallynumberfield',
fieldLabel: 'Date Range (months)'
}
];
},
launch: function() {
this._getAllChildProjectsForCurrentProject(this.project);
},
_getAllChildProjectsForCurrentProject: function(currProject){
Ext.getBody().mask('Loading...');
this.allProjectsList = [];
var that = this;
var projectStore = Ext.create('Rally.data.wsapi.Store', {
model: 'Project',
fetch: ['Name', 'State', 'Parent', 'Children'],
autoLoad: true,
compact: false,
context: {
workspace: that.getContext().getWorkspace()._Ref,
projectScopeUp: false,
projectScopeDown: true
},
limit: Infinity,
filters:[{
property:'State',
operator: '=',
value: 'Open'
}],
sorters: [{
property: 'Name',
direction: 'ASC'
}],
listeners: {
load: function(projectStore, data, success){
//initiatilinzing the list containing the required and all projects.
this.requiredProjectsList = [];
this.allProjectsColl = data;
//identifying the selected project and constructing its reference.
var selectedProj = this.getContext().getProject();
var selectedProjRef = '/project/' + selectedProj.ObjectID;
//registering the selected project reference.
this.requiredProjectsList.push(selectedProj.ObjectID);
//identifying whether selected project has any children.
var selectedProjChildren = selectedProj.Children;
if(selectedProjChildren && selectedProjChildren.Count > 0){
this._loadAllChildProjectsFromParent(selectedProjRef);
}
//creating the milestone Store Filter.
this._createMilestoneStoreFilter();
//creating Milestone store.
this._createMilestoneStore();
Ext.getBody().unmask();
},
scope: this
}
});
},
_loadAllChildProjectsFromParent: function(parentProjRef) {
var that = this;
Ext.Array.each(this.allProjectsColl, function(thisProject) {
//identifying current project is child of the Project with reference..
if(thisProject.get('Parent') && thisProject.get('Parent')._ref !== null && thisProject.get('Parent')._ref == parentProjRef){
that.requiredProjectsList.push(thisProject.data.ObjectID);
//identifying whether the project as any further children.
var projChildren = thisProject.get('Children');
if(projChildren && projChildren.Count > 0){
that._loadAllChildProjectsFromParent(thisProject.get('_ref'));
}
}
});
},
_createMilestoneStoreFilter: function(){
this.projectMilestoneFilter = Ext.create('Rally.data.wsapi.Filter', {
property: 'TargetDate',
operator: '>=',
value: 'today'
});
this.projectMilestoneFilter = this.projectMilestoneFilter.and(Ext.create('Rally.data.wsapi.Filter', {
property: 'Name',
operator: '=',
value: 'AP Invoice Approval 1.1'
}));
//only apply filtering on the notes field if configured
if (this.getSetting('executiveVisibilityOnly')) {
this.projectMilestoneFilter = this.projectMilestoneFilter.and(Ext.create('Rally.data.wsapi.Filter', {
property: 'c_ExecutiveVisibility',
operator: '=',
value: this.getSetting('executiveVisibilityOnly')
}));
}
//only filter on date range if configured
if (this.getSetting('showNumberOfMonths') && this.getSetting('showNumberOfMonths') > 0) {
var endDate = Rally.util.DateTime.add(new Date(), "month", this.getSetting('showNumberOfMonths'));
this.projectMilestoneFilter = this.projectMilestoneFilter.and(Ext.create('Rally.data.wsapi.Filter', {
property: 'TargetDate',
operator: '<=',
value: endDate
}));
}
},
_createMilestoneStore: function() {
var milestones = Ext.create('Rally.data.wsapi.Store', {
model: 'milestone',
fetch: ['Artifacts', 'FormattedID', 'Name', 'TargetProject', 'TargetDate', 'DisplayColor', 'Notes', 'c_ValueStream', 'c_ExecutiveVisibility'],
compact: false,
filters : this.projectMilestoneFilter,
context: {
workspace: this.getContext().getWorkspace()._Ref,
projectScopeUp: false,
projectScopeDown: true
},
sorters: [
{
property: 'c_ValueStream',
direction: 'ASC'
},
{
property: 'TargetDate',
direction: 'ASC'
}
]
});
milestones.load().then({
success: this._loadMilestoneArtifacts,
scope: this
}).then({
success: function(milestones) {
this._filterMilestones(milestones);
},
failure: function(error) {
console.log('Unable to load store: ' + error);
},
scope: this
});
},
_loadMilestoneArtifacts: function(milestones) {
_.each(milestones, function(milestone) {
var artifacts = milestone.get('Artifacts');
if(artifacts.Count > 0) {
artifacts.store = milestone.getCollection('Artifacts');
//artifacts.store.load();
}
});
//return milestones with loaded artifacts
return milestones;
},
//Only include milestones based on the current project and it's children
_filterMilestones: function(myData) {
var that = this;
//Filter out milestone will be stored here
var filteredMilestonesArr = [];
Ext.each(myData, function(data, index) {
var targetProject = data.data.TargetProject;
if(that.getSetting('includeGlobalMilestones') && (targetProject === null || targetProject === "")){
filteredMilestonesArr.push(data);
}
else if(targetProject !== null && targetProject !== "" && targetProject._ref !== null){
var projectObjectId =that._getTargetProjectObjectIDFromRef(targetProject._ref);
if(that.requiredProjectsList.indexOf(projectObjectId) > -1)
filteredMilestonesArr.push(data);
}
});
if (filteredMilestonesArr.length <= 0) {
Rally.ui.notify.Notifier.show({message: 'No data found for selected filters.'});
return;
}
else {
this._organiseMilestoneBasedOnValuestream(filteredMilestonesArr);
}
},
_organiseMilestoneBasedOnValuestream: function(filteredMilestonesArr){
this.valueStreamMilestoneColl = [];
this.valueStreamColl = [];
var nonVSCount = 0;
var that = this;
Ext.Array.each(filteredMilestonesArr, function(thisData){
var valuestream = thisData.get('c_ValueStream');
if(valuestream !== ''){
if(that.valueStreamColl.length === 0){
that.valueStreamColl.push(valuestream);
}
else if(that.valueStreamColl.length > 0 && that.valueStreamColl.indexOf(valuestream) === -1){
that.valueStreamColl.push(valuestream);
}
}
else{
nonVSCount++;
}
});
this.valueStreamColl.sort();
if(nonVSCount > 0) {
this.valueStreamColl.push('N/A');
}
Ext.Array.each(this.valueStreamColl, function(valuestream) {
var milestoneColl = that._getAllAssociatedMilestones(valuestream, filteredMilestonesArr);
that.valueStreamMilestoneColl.push({
key: valuestream,
value: milestoneColl
});
});
this._createValueStreamMilestonesTreeNode();
},
_createValueStreamMilestonesTreeNode: function(){
var valueStreamRootNode = Ext.create('MilestoneTreeModel',{
Name: 'ValueStream Root',
text: 'ValueStream Root',
root: true,
expandable: true,
expanded: true
});
this._createValueStreamNodesAlongWithAssociatedChildMilestoneNodes(valueStreamRootNode);
this._createValueStreamMilestoneGrid(valueStreamRootNode);
},
_createValueStreamMilestoneGrid: function(valueStreamRootNode){
var milestoneValueStreamTreeStore = Ext.create('Ext.data.TreeStore', {
model: 'MilestoneTreeModel',
root: valueStreamRootNode
});
var valuestreamMilestoneTreePanel = Ext.create('Ext.tree.Panel', {
store: milestoneValueStreamTreeStore,
useArrows: true,
rowLines: true,
displayField: 'Name',
rootVisible: false,
width: '100%',
height: 'auto', // Extra scroll for individual sections:
viewConfig: {
getRowClass: function(record, index) {
var nameRecord = Ext.String.format("{0}", record.get('Name'));
if(nameRecord && nameRecord.search('valuestream:') === -1){
return 'row-child';
}
return 'row-parent';
}
},
columns: [{
xtype: 'treecolumn',
text: 'Name',
dataIndex: 'Name',
resizeable: true,
flex: 3,
minWidth:200,
//width : 300,
renderer: function(value,style,item,rowIndex) {
var link = Ext.String.format("{0}", value);
if(link.search('valuestream:') === -1){
var ref = item.get('_ref');
link = Ext.String.format("<a target='_top' href='{1}'><b>{0}</b></a>", value, Rally.nav.Manager.getDetailUrl(ref));
}
else{
var onlyName = link.replace('valuestream:', '');
link= Ext.String.format("<b>{0}</b>", onlyName);
}
return link;
}
},
{
text: 'Project',
dataIndex: 'TargetProject',
flex: 2,
hidden: true
},
{
text: 'Target Date',
dataIndex: 'TargetDate',
flex: 1,
renderer: function(value){
if(value)
return Rally.util.DateTime.format(value, 'M Y');
}
},
{
text: 'Status',
dataIndex: 'DisplayColor',
flex: 1,
renderer: function(value){
if(value){
var colorHtml = Ext.String.format("<div class= 'color-box' style= 'background-color: {0};'></div>", value);
return colorHtml;
}
}
},
{
text: 'Notes',
dataIndex: 'Notes',
flex: 5
}
]
});
this.add(valuestreamMilestoneTreePanel);
},
_createValueStreamNodesAlongWithAssociatedChildMilestoneNodes: function(valustreamRootNode){
var that = this;
Ext.Array.each(this.valueStreamMilestoneColl, function(thisData) {
var valueStreamNode = that._createValueStreamNode(thisData.key);
Ext.Array.each(thisData.value, function(thisMilestoneData) {
var milestoneNode = that._createMilestoneNode(thisMilestoneData);
valueStreamNode.appendChild(milestoneNode);
});
valustreamRootNode.appendChild(valueStreamNode);
});
},
_createValueStreamNode: function(valuestreamData){
var valueStreamLable = 'valuestream: ' + valuestreamData;
var valustreamTreeNode = Ext.create('MilestoneTreeModel',{
Name: valueStreamLable,
leaf: false,
expandable: true,
expanded: true,
iconCls :'no-icon'
});
return valustreamTreeNode;
},
_createMilestoneNode: function(milestoneData){
var targetProjectName = milestoneData.get('TargetProject') !== null ? milestoneData.get('TargetProject')._refObjectName : 'Global';
var milestoneTreeNode = Ext.create('MilestoneTreeModel',{
FormattedID: milestoneData.get('FormattedID'),
Name: milestoneData.get('Name'),
TargetDate: milestoneData.get('TargetDate'),
TargetProject: targetProjectName,
DisplayColor: milestoneData.get('DisplayColor'),
Notes: milestoneData.get('Notes'),
_ref: milestoneData.get('_ref'),
leaf: true,
expandable: false,
expanded: false,
iconCls :'no-icon'
});
this._createArtifactNodesForMilestone(milestoneData, milestoneTreeNode);
return milestoneTreeNode;
},
_createArtifactNodesForMilestone: function(milestoneData, milestoneNode) {
var that = this;
var totalLeafNodes = 0, acceptedLeafNodes = 0;
console.log(milestoneData);
console.log('artifact store...');
var artifactTreeNodeCollection = [];
milestoneData.getCollection('Artifacts').load({
fetch: ['FormattedID', 'Name', '_type', 'ObjectID'],
callback: function(records, operation, success) {
Ext.Array.each(records, function(artifact) {
//create a model based on the type and load
var model = Rally.data.ModelFactory.getModel({
type: artifact.get('_type'),
success: function(model) {
model.load(artifact.get('ObjectID'), {
callback: function(result, operation) {
if(operation.wasSuccessful()) {
that.totalLeafNodes += result.get('AcceptedLeafStoryCount');
that.acceptedLeafNodes += result.get('AcceptedLeafStoryCount');
console.log('got feature; # of stories:' + result.get('LeafStoryCount'));
}
}
});
},
scope: this
});
});
}
}).then({
success: function() {
console.log('Total Stories for Milestone: ' + that.totalLeafNodes);
},
scope: this
});
/*
Ext.Array.each(artifacts, function(artifact) {
console.log(artifact);
});
if (artifact.isPortfolioItem) {
var portfolioModel = Rally.data.ModelFactory.getModel({
type: artifact.get('_type')
});
portfolioModel.load(objectId).then({
success: function(result, operation) {
console.log(result);
},
scope: this
});
//create a model based on the type and load
var model = Rally.data.ModelFactory.getModel({
type: artifact.get('_type'),
success: function(model) {
model.load(objectId, {
callback: function(result, operation) {
if(operation.wasSuccessful()) {
totalLeafNodes += artifact.get('AcceptedLeafStoryCount');
acceptedLeafNodes += artifact.get('AcceptedLeafStoryCount');
}
}
});
},
scope: this
});
var artifactNode = Ext.create('ArtifactTreeModel', {
FormattedID: artifact.get('FormattedID'),
Name: artifact.get('Name'),
TotalLeafArtifacts: artifact.get('LeafStoryCount'),
AcceptedLeafArtifacts: artifact.get('AcceptedLeafStoryCount'),
TotalLeafPlanEstimate: artifact.get('LeafStoryPlanEstimateTotal'),
AcceptedLeafPlanEstimate: artifact.get('AcceptedLeafStoryPlanEstimateTotal'),
_ref: artifact.get('_ref'),
leaf: true,
expandable: false,
expanded: false,
iconCls: 'no-icon'
});
artifactTreeNodeCollection.push(artifactNode);
}
});*/
},
_getAllAssociatedMilestones: function(valuestream, milestoneStoreData){
var milestoneColl = [];
var that = this;
Ext.Array.each(milestoneStoreData, function(milestone) {
var vsRecord = milestone.get('c_ValueStream');
vsRecord = vsRecord !== '' ? vsRecord : 'NA';
if(vsRecord === valuestream){
milestoneColl.push(milestone);
}
});
return milestoneColl;
},
_getTargetProjectObjectIDFromRef: function(_ref){
var objectId = Number(_ref.replace('/project/', ''));
return objectId;
}
}); |
/**
* A small exercise in parallax scrolling.
* Pleas look at http://en.wikipedia.org/wiki/Parallax_scrolling for more information on the topic.
* Wikipedia is also the source for the images used here.
*/
window.onload = (function() {
var WIDTH = 640, HEIGHT = 480;
var IMG_GROUND = "../img/Ground_front_layer.png",
IMG_VEG = "../img/Vegetation_middle_layer.png",
IMG_SKY = "../img/Sky_back_layer.png";
Crafty.init(WIDTH, HEIGHT);
/* Load the images and then create the Scroller */
Crafty.load([IMG_GROUND, IMG_SKY, IMG_VEG], function() {
Crafty.c("Scroller", {
init: function() {
/* Create an Entity for every image.
* The "repeat" is essential here as the Entity's width is 3x the canvas width (which equals
* the width of the original image).
*/
this._bgImage = Crafty.e("2D, DOM, Image").image(IMG_SKY, "repeat")
.attr({x:0, y:0, w: WIDTH * 3, h:HEIGHT});
this._mdImage = Crafty.e("2D, DOM, Image").image(IMG_VEG, "repeat")
.attr({x:0, y:0, w: WIDTH * 3, h:HEIGHT});
this._fgImage = Crafty.e("2D, DOM, Image").image(IMG_GROUND, "repeat")
.attr({x:0, y:0, w: WIDTH * 3, h:HEIGHT});
/* Move the image entities to the left (by different offsets) on every 'EnterFrame'
* Also, if we move them too far, adjust by adding one image width
*/
this.bind("EnterFrame", function() {
this._bgImage.x -= 2;
this._mdImage.x -= 3;
this._fgImage.x -= 5;
if (this._bgImage.x < -WIDTH) this._bgImage.x += WIDTH;
if (this._mdImage.x < -WIDTH) this._mdImage.x += WIDTH;
if (this._fgImage.x < -WIDTH) this._fgImage.x += WIDTH;
});
}
});
Crafty.e("Scroller");
});
});
|
var I = [
[
[0, 0, 0, 0],
[1, 1, 1, 1],
[0, 0, 0, 0],
[0, 0, 0, 0],
],
[
[0, 0, 1, 0],
[0, 0, 1, 0],
[0, 0, 1, 0],
[0, 0, 1, 0],
],
[
[0, 0, 0, 0],
[0, 0, 0, 0],
[1, 1, 1, 1],
[0, 0, 0, 0],
],
[
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 0, 0],
]
];
var J = [
[
[1, 0, 0],
[1, 1, 1],
[0, 0, 0]
],
[
[0, 1, 1],
[0, 1, 0],
[0, 1, 0]
],
[
[0, 0, 0],
[1, 1, 1],
[0, 0, 1]
],
[
[0, 1, 0],
[0, 1, 0],
[1, 1, 0]
]
];
var L = [
[
[0, 0, 1],
[1, 1, 1],
[0, 0, 0]
],
[
[0, 1, 0],
[0, 1, 0],
[0, 1, 1]
],
[
[0, 0, 0],
[1, 1, 1],
[1, 0, 0]
],
[
[1, 1, 0],
[0, 1, 0],
[0, 1, 0]
]
];
var O = [
[
[0, 0, 0, 0],
[0, 1, 1, 0],
[0, 1, 1, 0],
[0, 0, 0, 0],
]
];
var S = [
[
[0, 1, 1],
[1, 1, 0],
[0, 0, 0]
],
[
[0, 1, 0],
[0, 1, 1],
[0, 0, 1]
],
[
[0, 0, 0],
[0, 1, 1],
[1, 1, 0]
],
[
[1, 0, 0],
[1, 1, 0],
[0, 1, 0]
]
];
var T = [
[
[0, 1, 0],
[1, 1, 1],
[0, 0, 0]
],
[
[0, 1, 0],
[0, 1, 1],
[0, 1, 0]
],
[
[0, 0, 0],
[1, 1, 1],
[0, 1, 0]
],
[
[0, 1, 0],
[1, 1, 0],
[0, 1, 0]
]
];
var Z = [
[
[1, 1, 0],
[0, 1, 1],
[0, 0, 0]
],
[
[0, 0, 1],
[0, 1, 1],
[0, 1, 0]
],
[
[0, 0, 0],
[1, 1, 0],
[0, 1, 1]
],
[
[0, 1, 0],
[1, 1, 0],
[1, 0, 0]
]
];
|
var request = require('request-promise');
var errors = require('request-promise/errors');
var Hashids = require('hashids');
var _ = require('lodash');
var api = function (config) {
var self = this;
self.api_url = config.api;
self.api_key = config.api_key;
self.secret = config.secret;
var hashids = new Hashids(self.secret, 6, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
var hashids16 = new Hashids(self.secret, 16, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789');
var auth = function (accessKey) {
return {
'Authorization': 'Bearer ' + accessKey
};
};
var path = function (_path, query) {
if (query) {
var queryString = Object.keys(query).reduce(function (a, k) {
a.push(k + '=' + encodeURIComponent(query[k]));
return a;
}, []).join('&');
return self.api_url + '/' + _path + '?' + queryString;
} else {
return self.api_url + '/' + _path;
}
};
var network = function (user_id, email) {
return 'Network ' + hashids.encode(user_id) + ' for (' + email + ')';
};
self.getUserByEmail = function (email) {
return new Promise(function (resolve, reject) {
console.log(self.api_url+','+self.api_key)
// get user by email
request.get(path('user', {login: email}), {
headers: auth(self.api_key),
json: true
}).then(function (response) {
if (response && response.length) {
return resolve({user: response[0], email: email});
}
console.log('User ' + email + ' does not exist yet. Creating...');
self.createUser(email).then(function (response) {
return resolve({user: response, email: email});
})['catch'](reject);
})['catch'](reject);
});
};
self.getNetwork = function (data) {
return new Promise(function (resolve, reject) {
if (!data || !data.user || !data.user.id) {
reject({message: 'user id is required'});
}
var networkName = network(data.user.id, data.email);
var networkKey = hashids16.encode(data.user.id);
// get network
request.get(path('network', {name: networkName}), {
headers: auth(self.api_key),
json: true
}).then(function (response) {
if (response && response.length) {
return resolve(_.extend(data, {network: response[0]}));
}
console.log('User ' + data.email + ' has no network key yet. Creating...');
self.createNetwork(networkName, networkKey).then(function (response) {
return resolve(_.extend(data, {network: response}));
})['catch'](reject);
})['catch'](reject);
});
};
self.assignNetwork = function (data) {
return new Promise(function (resolve, reject) {
if (!data || !data.user || !data.user.id) {
reject({message: 'user id is required'});
}
if (!data || !data.network || !data.network.id) {
reject({message: 'network id is required'});
}
// get network
request.put(path('user/' + data.user.id + '/network/' + data.network.id),
{headers: auth(self.api_key), json: true}).then(function (response) {
return resolve(data);
})['catch'](reject);
});
};
self.getAccessKey = function (data) {
return new Promise(function (resolve, reject) {
if (!data || !data.user || !data.user.id) {
reject({message: 'user id is required'});
}
// get accesskey
request.get(path('user/' + data.user.id + '/accesskey'), {
headers: auth(self.api_key),
json: true
}).then(function (response) {
if (response && response.length) {
return resolve(_.extend(data, {accessKey: response[0]}));
}
console.log('User ' + data.email + ' has no access key yet. Creating...');
self.createAccessKey(data.user.id, data.email).then(function (response) {
return resolve(_.extend(data, {accessKey: response}));
})['catch'](reject);
})['catch'](reject);
});
};
self.createUser = function (email) {
var user = {
status: 0, // active
role: 1, // client role
login: email,
password: "" // no login by password
};
return request.post(path('user'), {headers: auth(self.api_key), body: user, json: true});
};
self.createNetwork = function (name, key) {
var network = {
name: name,
key: key,
description: 'Playground Network'
};
return request.post(path('network'), {headers: auth(self.api_key), body: network, json: true});
};
self.createAccessKey = function (user_id, email) {
var token = {
type: 0, // Default access token
label: 'Default access token for ' + email,
permissions: [{
domains: null,
subnets: null,
actions: ['GetNetwork'
, 'GetDevice'
, 'GetDeviceState'
, 'GetDeviceNotification'
, 'GetDeviceCommand'
, 'RegisterDevice'
, 'CreateDeviceNotification'
, 'CreateDeviceCommand'
, 'UpdateDeviceCommand'
, 'GetCurrentUser'
, 'UpdateCurrentUser'
, 'ManageAccessKey'
, 'ManageOAuthGrant'],
networkIds: null, // all user networks
deviceGuids: null // all user devices
}]
};
return request.post(path('user/' + user_id + '/accesskey'), {
headers: auth(self.api_key),
body: token,
json: true
});
};
return self;
};
module.exports = api; |
import React, {Component, PropTypes} from 'react';
import ReactDOM from 'react-dom';
import {storiesOf} from '@kadira/storybook';
import style from './Storybook.scss';
import {SortableContainer, SortableElement, SortableHandle, arrayMove} from '../index';
import {defaultFlexTableRowRenderer, FlexColumn, FlexTable, VirtualScroll} from 'react-virtualized';
import 'react-virtualized/styles.css';
import Infinite from 'react-infinite';
import range from 'lodash/range';
import random from 'lodash/random';
import classNames from 'classnames';
function getItems(count, height) {
var heights = [65, 110, 140, 65, 90, 65];
return range(count).map((value) => {
return {
value,
height: height || heights[random(0, heights.length - 1)]
};
});
}
const Handle = SortableHandle(() => <div className={style.handle}></div>);
const Item = SortableElement((props) => {
return (
<div className={props.className} style={{
height: props.height
}}>
{props.useDragHandle && <Handle/>}
Item {props.value}
</div>
)
});
class ListWrapper extends Component {
constructor({items}) {
super();
this.state = {
items
};
}
static propTypes = {
items: PropTypes.array,
className: PropTypes.string,
itemClass: PropTypes.string,
width: PropTypes.number,
height: PropTypes.number,
onSortEnd: PropTypes.func,
component: PropTypes.func
}
static defaultProps = {
className: classNames(style.list, style.stylizedList),
itemClass: classNames(style.item, style.stylizedItem),
width: 400,
height: 600
};
onSortEnd = ({oldIndex, newIndex}) => {
let {onSortEnd} = this.props;
let {items} = this.state;
arrayMove(items, oldIndex, newIndex);
this.setState({items});
if (onSortEnd) {
onSortEnd(this.refs.component);
}
};
render() {
const Component = this.props.component;
const {items} = this.state;
return <Component ref="component" {...this.props} items={items} onSortEnd={this.onSortEnd} />;
}
}
// Function components cannot have refs, so we'll be using a class for React Virtualized
class VirtualList extends Component {
render() {
let {className, items, height, width, itemHeight, itemClass, sortingIndex} = this.props;
return (
<VirtualScroll
ref="vs"
className={className}
rowHeight={({index}) => items[index].height}
estimatedRowSize={itemHeight}
rowRenderer={({index}) => {
let {value, height} = items[index];
return <Item index={index} className={itemClass} sortingIndex={sortingIndex} value={value} height={height}/>;
}}
rowCount={items.length}
width={width}
height={height}
/>
);
}
}
const SortableVirtualList = SortableContainer(VirtualList, {withRef: true});
const SortableFlexTable = SortableContainer(FlexTable, {withRef: true});
const SortableRowRenderer = SortableElement(defaultFlexTableRowRenderer);
class FlexTableWrapper extends Component {
render () {
const {
className,
height,
helperClass,
itemClass,
itemHeight,
items,
onSortEnd,
width
} = this.props
return (
<SortableFlexTable
getContainer={(wrappedInstance) => ReactDOM.findDOMNode(wrappedInstance.Grid)}
gridClassName={className}
headerHeight={itemHeight}
height={height}
helperClass={helperClass}
onSortEnd={onSortEnd}
rowClassName={itemClass}
rowCount={items.length}
rowGetter={({ index }) => items[index]}
rowHeight={itemHeight}
rowRenderer={(props) => <SortableRowRenderer {...props} />}
width={width}
>
<FlexColumn
label='Index'
dataKey='value'
width={100}
/>
<FlexColumn
label='Height'
dataKey='height'
width={width - 100}
/>
</SortableFlexTable>
);
}
}
const SortableInfiniteList = SortableContainer(({className, items, itemClass, sortingIndex}) => {
return (
<Infinite
className={className}
containerHeight={600}
elementHeight={items.map(({height}) => height)}
>
{items.map(({value, height}, index) =>
<Item
key={`item-${index}`}
className={itemClass}
sortingIndex={sortingIndex}
index={index}
value={value}
height={height}
/>
)}
</Infinite>
)
});
const SortableList = SortableContainer(({className, items, itemClass, sortingIndex, useDragHandle}) => {
return (
<div className={className}>
{items.map(({value, height}, index) =>
<Item
key={`item-${value}`}
className={itemClass}
sortingIndex={sortingIndex}
index={index}
value={value}
height={height}
useDragHandle={useDragHandle}
/>
)}
</div>
);
});
storiesOf('Basic Configuration', module)
.add('Basic usage', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} items={getItems(50, 59)} helperClass={style.stylizedHelper} />
</div>
);
})
.add('Drag handle', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} useDragHandle={true} items={getItems(50, 59)} helperClass={style.stylizedHelper} />
</div>
);
})
.add('Elements of varying heights', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} items={getItems(50)} helperClass={style.stylizedHelper} />
</div>
);
})
.add('Horizontal', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} axis={'x'} items={getItems(50, 300)} helperClass={style.stylizedHelper} className={classNames(style.list, style.stylizedList, style.horizontalList)} itemClass={classNames(style.stylizedItem, style.horizontalItem)} />
</div>
);
})
storiesOf('Advanced', module)
.add('Press delay (200ms)', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} items={getItems(50, 59)} pressDelay={200} helperClass={style.stylizedHelper} />
</div>
);
})
.add('Lock axis', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} items={getItems(50)} helperClass={style.stylizedHelper} lockAxis={'y'} lockToContainerEdges={true} lockOffset={['0%', '100%']} />
</div>
);
})
.add('Window as scroll container', () => {
return (
<ListWrapper component={SortableList} items={getItems(50, 59)} className="" useWindowAsScrollContainer={true} helperClass={style.stylizedHelper} />
);
})
storiesOf('Customization', module)
.add('Minimal styling', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} items={getItems(50)} className={style.list} itemClass={style.item} helperClass={style.helper} />
</div>
);
})
.add('Transition duration', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} items={getItems(50, 59)} transitionDuration={450} helperClass={style.stylizedHelper} />
</div>
);
})
.add('Disable transitions', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableList} items={getItems(50, 59)} transitionDuration={0} helperClass={style.stylizedHelper} />
</div>
);
})
storiesOf('React Virtualized', module)
.add('Basic usage', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableVirtualList} items={getItems(500, 59)} itemHeight={59} helperClass={style.stylizedHelper} />
</div>
);
})
.add('Elements of varying heights', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableVirtualList} items={getItems(500)} itemHeight={89} helperClass={style.stylizedHelper}
onSortEnd={(ref) => {
// We need to inform React Virtualized that the item heights have changed
let instance = ref.getWrappedInstance();
let vs = instance.refs.vs;
vs.recomputeRowHeights();
instance.forceUpdate();
}}
/>
</div>
);
})
.add('FlexTable usage', () => {
return (
<div className={style.root}>
<ListWrapper component={FlexTableWrapper} items={getItems(500, 50)} itemHeight={50} helperClass={style.stylizedHelper} />
</div>
);
})
storiesOf('React Infinite', module)
.add('Basic usage', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableInfiniteList} items={getItems(500, 59)} helperClass={style.stylizedHelper} />
</div>
);
})
.add('Elements of varying heights', () => {
return (
<div className={style.root}>
<ListWrapper component={SortableInfiniteList} items={getItems(500)} helperClass={style.stylizedHelper} />
</div>
);
})
|
import React from 'react'
import {View, TouchableOpacity, Text, StyleSheet, ScrollView, Dimensions} from 'react-native'
import {connect} from 'react-redux'
import Button from '../../components/controls/Button'
import * as layoutActions from '../../actions/layoutActions'
import * as LoginActions from '../../actions/loginActions'
import firebase from 'firebase'
import { FormElementProperties, ContainerProperties, ScaleProperties, CommonProperties } from '../../common/StyleConstants'
class Welcome extends React.Component{
constructor(){
super()
}
handleLaunchGame(){
}
componentWillMount(){
this.onLayoutChnage()
}
handleProfile(){
this.props.navigator.push({
screen: 'FBLogin.Profile',
title: 'Profile',
animated: 'false',
animationType: 'slide-horizontal',
passProps: {},
navigatorStyle: {navBarHidden:false}
})
}
handleLogout(){
this.props.dispatch(LoginActions.logOut(firebase));
// this.props.navigator.popToRoot({
// animated: true, // does the popToRoot have transition animation or does it happen immediately (optional)
// animationType: 'slide-horizontal', // 'fade' (for both) / 'slide-horizontal' (for android) does the popToRoot have different transition animation (optional)
// });
}
onLayoutChnage(){
const {height, width} = Dimensions.get('window');
this.props.dispatch(layoutActions.setLayoutDimentions(width, height))
}
render(){
const conditionalBorderColorLogin = CommonProperties.borderColor
const conditionalTextColorLogin = CommonProperties.textColor
const launchButton = {
height: ScaleProperties.gameLaunchBoxSizeX,
width: (this.props.layoutWidth - 20),
marginBottom:10,
borderRadius: FormElementProperties.borderRadius
}
const controllButton = {
height: CommonProperties.inputElementMinHeightX,
width: (this.props.layoutWidth/2 - 10),
marginLeft: 5,
marginRight: 5,
}
return(
<View style={styles.viewContainer}>
<View style={styles.welcomeMessageContainer}>
<Text style={styles.welcomeMessageText}>Games</Text>
</View>
<ScrollView onLayout={this.onLayoutChnage.bind(this)}>
<View style={styles.gamesContainer}>
<Button
buttonStyle={launchButton}
buttonTextStyle={{}}
isDisabled={false}
buttonText={"Sweeper"}
eventHandler={this.handleLaunchGame.bind(this)}>
</Button>
<Button
buttonStyle={launchButton}
isDisabled={false}
buttonText={"Tic Tac"}
eventHandler={this.handleLaunchGame.bind(this)}>
</Button>
</View>
</ScrollView>
<View style={styles.controlBox}>
<Button
buttonStyle={controllButton}
isDisabled={false}
buttonText={"Logout"}
eventHandler={this.handleLogout.bind(this)}>
</Button>
<Button
buttonStyle={controllButton}
isDisabled={false}
buttonText={"Profile"}
eventHandler={this.handleProfile.bind(this)}>
</Button>
</View>
</View>
)
}
}
const storeProps = (store) => ({
name : store.user.displayName,
layoutWidth: store.layout.layoutWidth,
layoutHeight: store.layout.layoutHeight,
})
export default connect(storeProps)(Welcome)
const styles = StyleSheet.create({
viewContainer: {
backgroundColor: ContainerProperties.backgroundColor,
flex: 1,
//justifyContent: 'center',
},
welcomeMessageContainer: {
//display: 'none'
marginTop: 10
},
welcomeMessageText: {
fontSize: ScaleProperties.fontSizeXXX,
alignSelf: 'center',
color: CommonProperties.textColor
},
gamesContainer: {
//borderWidth: CommonProperties.borderWidth,
//borderColor: CommonProperties.borderColor,
//flexGrow:1,
flexDirection: 'row',
margin: 10,
marginTop:20,
//alignSelf:'center',
justifyContent: 'space-around',
//alignItems:'flex-start',
//width: 400,
//height:800,
//backgroundColor: 'pink',
flexWrap: 'wrap'
},
controlBox: {
flexDirection: 'row',
justifyContent: 'space-between',
minHeight: CommonProperties.inputElementMinHeightX,
marginBottom:5
},
launchButtonText: {
}
})
|
import React from 'react'
import { Link } from 'react-router'
import Helmet from 'react-helmet'
import { config } from 'config'
import { prefixLink } from 'gatsby-helpers'
export default class Index extends React.Component {
render() {
return (
<div>
<Helmet title={config.siteTitle + ' | contact'} />
<h1>
Contact us
</h1>
<p>
<div className="uptext">
If you have any questions about our group or the different research works,
do not hesitate to contact the appropiate person (<Link className="link" to={prefixLink('/people/')}>People</Link>).
</div>
<br/>
<div className="uptext">
Universidad Nacional de Colombia<br/>
Sede Manizales<br/>
Campus La Nubia<br/>
W. 216<br/>
Phone: +57 6 8879300 ext 55631
</div>
<center><img src="/images/build_w.jpg" alt=""/></center>
<center>W Building, Campus La Nubia.</center>
</p>
</div>
)
}
}
|
'use strict';
var execFileSync = require('child_process').execFileSync;
var sizeOf = require('image-size');
var mkdirp = require('mkdirp')
var rimraf = require('rimraf-then');
var fs = require('fs');
var path = require('path');
function tileLevel(inPath, outPath, zoom, tileSize, pattern, quality) {
var dotExtension = pattern.replace(/.*(\.[^.]+)$/, '$1');
var patternedFilename = pattern.replace(/\{z\}/, '' + zoom)
.replace(/\{x\}/, '%[fx:page.x/' + tileSize + ']')
.replace(/\{y\}/, '%[fx:page.y/' + tileSize + ']')
.replace(/\.[^.]+$/, '');
var patternedFilenameWithoutTheFilename = '';
if (pattern.indexOf(path.sep) > 0) {
patternedFilenameWithoutTheFilename = pattern.replace(new RegExp(path.sep + '[^' + path.sep + ']*$'), '')
.replace(/\{z\}/, '' + zoom);
}
return mkdirp(outPath + path.sep + patternedFilenameWithoutTheFilename)
.then(() => {
var args = [inPath,
'-crop', tileSize + 'x' + tileSize,
'-set', 'filename:tile', patternedFilename,
'-quality', quality, '+repage', '+adjoin',
outPath + '/%[filename:tile]' + dotExtension];
execFileSync('convert', args);
});
}
function imageBiggerThanTile(path, tileSize) {
var size = sizeOf(path);
return size.height > tileSize || size.width > tileSize;
}
function tileRec(inPath, outPath, zoom, tileSize, tempDir, pattern, zoomToDisplay, invertZoom, quality) {
var inPathMpc = tempDir + '/temp_level_' + zoom + '.mpc';
var inPathCache = tempDir + '/temp_level_' + zoom + '.cache';
execFileSync('convert', [inPath, inPathMpc]);
return tileLevel(inPathMpc, outPath, zoomToDisplay, tileSize, pattern, quality)
.then(function () {
if (imageBiggerThanTile(inPath, tileSize)) {
var newZoom = zoom + 1;
var newZoomToDisplay = zoomToDisplay + 1;
if (!invertZoom) {
newZoomToDisplay = zoomToDisplay - 1;
}
var newInPath = tempDir + '/temp_level_' + zoom + '.png';
execFileSync('convert', [inPathMpc, '-resize', '50%', '-quality', quality, newInPath]);
fs.unlinkSync(inPathMpc);
fs.unlinkSync(inPathCache);
return tileRec(newInPath, outPath, newZoom, tileSize, tempDir, pattern, newZoomToDisplay, invertZoom, quality);
} else {
fs.unlinkSync(inPathMpc);
fs.unlinkSync(inPathCache);
}
});
}
module.exports.tile = function (inPath, outPath, pattern, options) {
options = options || {};
var tileSize = options.tileSize || 256;
var tmpDir = options.tmpDir || process.env.TMPDIR || '/tmp';
var tempDir = tmpDir + '/image-tiler_' + process.pid;
var zoom = 0;
var zoomToDisplay = 0;
var quality = options.quality || 100;
if (!options.invertZoom) {
var size = sizeOf(inPath);
var halvingsWidth = Math.ceil(Math.log2(Math.ceil(size.width / tileSize)));
var halvingsheight = Math.ceil(Math.log2(Math.ceil(size.height / tileSize)));
zoomToDisplay = Math.max(halvingsWidth, halvingsheight);
}
return mkdirp(tempDir)
.then(() => tileRec(inPath, outPath, zoom, tileSize, tempDir, pattern, zoomToDisplay, options.invertZoom, quality))
.then(() => rimraf(tempDir));
};
|
'use strict';
var self = put;
module.exports = self;
var async = require('async');
var _ = require('underscore');
function put(req, res) {
var bag = {
inputParams: req.params,
reqBody: req.body,
resBody: {}
};
bag.who = util.format('systemMachineImages|%s', self.name);
logger.info(bag.who, 'Starting');
async.series([
_checkInputParams.bind(null, bag),
_getSystemMachineImage.bind(null, bag),
_put.bind(null, bag),
_getUpdatedSystemMachineImage.bind(null, bag)
],
function (err) {
logger.info(bag.who, 'Completed');
if (err)
return respondWithError(res, err);
sendJSONResponse(res, bag.resBody);
}
);
}
function _checkInputParams(bag, next) {
var who = bag.who + '|' + _checkInputParams.name;
logger.verbose(who, 'Inside');
if (!bag.reqBody)
return next(
new ActErr(who, ActErr.BodyNotFound, 'Missing body')
);
if (!bag.inputParams.systemMachineImageId)
return next(
new ActErr(who, ActErr.ParamNotFound,
'Route parameter not found :systemMachineImageId')
);
return next();
}
function _getSystemMachineImage(bag, next) {
var who = bag.who + '|' + _getSystemMachineImage.name;
logger.verbose(who, 'Inside');
var query = util.format('SELECT * FROM "systemMachineImages" WHERE id=\'%s\'',
bag.inputParams.systemMachineImageId);
global.config.client.query(query,
function (err, systemMachineImages) {
if (err)
return next(
new ActErr(who, ActErr.DBOperationFailed,
'Failed to get systemMachineImages with error: ' +
util.inspect(err))
);
if (_.isEmpty(systemMachineImages.rows))
return next(
new ActErr(who, ActErr.DBEntityNotFound,
'systemMachineImage not found for id: ' +
bag.inputParams.systemMachineImageId)
);
logger.debug('Found systemMachineImage for ' +
bag.inputParams.systemMachineImageId);
bag.systemMachineImage = systemMachineImages.rows[0];
return next();
}
);
}
function _put(bag, next) {
/* jshint maxcomplexity:25 */
var who = bag.who + '|' + _put.name;
logger.verbose(who, 'Inside');
var updates = ['"updatedAt"=CURRENT_TIMESTAMP'];
if (_.has(bag.reqBody, 'externalId'))
updates.push(util.format('"externalId"=\'%s\'', bag.reqBody.externalId));
if (_.has(bag.reqBody, 'provider'))
updates.push(util.format('"provider"=\'%s\'', bag.reqBody.provider));
if (_.has(bag.reqBody, 'name'))
updates.push(util.format('"name"=\'%s\'', bag.reqBody.name));
if (_.has(bag.reqBody, 'isAvailable'))
updates.push(util.format('"isAvailable"=\'%s\'', bag.reqBody.isAvailable));
if (_.has(bag.reqBody, 'isDefault'))
updates.push(util.format('"isDefault"=\'%s\'', bag.reqBody.isDefault));
if (_.has(bag.reqBody, 'region'))
updates.push(util.format('"region"=\'%s\'', bag.reqBody.region));
if (_.has(bag.reqBody, 'keyName'))
updates.push(util.format('"keyName"=\'%s\'', bag.reqBody.keyName));
if (_.has(bag.reqBody, 'runShImage'))
updates.push(util.format('"runShImage"=\'%s\'', bag.reqBody.runShImage));
if (_.has(bag.reqBody, 'securityGroup'))
updates.push(
util.format('"securityGroup"=\'%s\'', bag.reqBody.securityGroup));
if (_.has(bag.reqBody, 'subnetId'))
updates.push(util.format('"subnetId"=\'%s\'', bag.reqBody.subnetId));
if (_.has(bag.reqBody, 'drydockTag'))
updates.push(util.format('"drydockTag"=\'%s\'', bag.reqBody.drydockTag));
if (_.has(bag.reqBody, 'drydockFamily'))
updates.push(
util.format('"drydockFamily"=\'%s\'', bag.reqBody.drydockFamily));
updates = updates.join(', ');
var query = util.format('UPDATE "systemMachineImages" SET %s WHERE id=\'%s\'',
updates, bag.inputParams.systemMachineImageId);
global.config.client.query(query,
function (err) {
if (err)
return next(
new ActErr(who, ActErr.DBOperationFailed,
'Failed to update systemMachineImage with error: ' +
util.inspect(err))
);
return next();
}
);
}
function _getUpdatedSystemMachineImage(bag, next) {
var who = bag.who + '|' + _getUpdatedSystemMachineImage.name;
logger.verbose(who, 'Inside');
var query = util.format('SELECT * FROM "systemMachineImages" WHERE id=\'%s\'',
bag.inputParams.systemMachineImageId);
global.config.client.query(query,
function (err, systemMachineImages) {
if (err)
return next(
new ActErr(who, ActErr.DBOperationFailed,
'Failed to get systemMachineImage with error: ' + util.inspect(err))
);
if (_.isEmpty(systemMachineImages.rows))
return next(
new ActErr(who, ActErr.DBEntityNotFound,
'systemMachineImages not found for id: ' +
bag.inputParams.systemMachineImageId)
);
logger.debug('Found systemMachineImages for ' +
bag.inputParams.systemMachineImageId);
bag.resBody = systemMachineImages.rows[0];
return next();
}
);
}
|
/**
* index.js - delish
*
* Licened under MIT license.
* Copyright (C) 2017 Karim Alibhai.
*/
require('babel-register')
require('./lib/env')
const http = require('./lib').default
http.listen(process.env.PORT || 8080, () =>
console.log('Listening :%s', http.address().port)
) |
// All code points with the `Grapheme_Extend` derived core property as per Unicode v5.2.0:
[
0x300,
0x301,
0x302,
0x303,
0x304,
0x305,
0x306,
0x307,
0x308,
0x309,
0x30A,
0x30B,
0x30C,
0x30D,
0x30E,
0x30F,
0x310,
0x311,
0x312,
0x313,
0x314,
0x315,
0x316,
0x317,
0x318,
0x319,
0x31A,
0x31B,
0x31C,
0x31D,
0x31E,
0x31F,
0x320,
0x321,
0x322,
0x323,
0x324,
0x325,
0x326,
0x327,
0x328,
0x329,
0x32A,
0x32B,
0x32C,
0x32D,
0x32E,
0x32F,
0x330,
0x331,
0x332,
0x333,
0x334,
0x335,
0x336,
0x337,
0x338,
0x339,
0x33A,
0x33B,
0x33C,
0x33D,
0x33E,
0x33F,
0x340,
0x341,
0x342,
0x343,
0x344,
0x345,
0x346,
0x347,
0x348,
0x349,
0x34A,
0x34B,
0x34C,
0x34D,
0x34E,
0x34F,
0x350,
0x351,
0x352,
0x353,
0x354,
0x355,
0x356,
0x357,
0x358,
0x359,
0x35A,
0x35B,
0x35C,
0x35D,
0x35E,
0x35F,
0x360,
0x361,
0x362,
0x363,
0x364,
0x365,
0x366,
0x367,
0x368,
0x369,
0x36A,
0x36B,
0x36C,
0x36D,
0x36E,
0x36F,
0x483,
0x484,
0x485,
0x486,
0x487,
0x488,
0x489,
0x591,
0x592,
0x593,
0x594,
0x595,
0x596,
0x597,
0x598,
0x599,
0x59A,
0x59B,
0x59C,
0x59D,
0x59E,
0x59F,
0x5A0,
0x5A1,
0x5A2,
0x5A3,
0x5A4,
0x5A5,
0x5A6,
0x5A7,
0x5A8,
0x5A9,
0x5AA,
0x5AB,
0x5AC,
0x5AD,
0x5AE,
0x5AF,
0x5B0,
0x5B1,
0x5B2,
0x5B3,
0x5B4,
0x5B5,
0x5B6,
0x5B7,
0x5B8,
0x5B9,
0x5BA,
0x5BB,
0x5BC,
0x5BD,
0x5BF,
0x5C1,
0x5C2,
0x5C4,
0x5C5,
0x5C7,
0x610,
0x611,
0x612,
0x613,
0x614,
0x615,
0x616,
0x617,
0x618,
0x619,
0x61A,
0x64B,
0x64C,
0x64D,
0x64E,
0x64F,
0x650,
0x651,
0x652,
0x653,
0x654,
0x655,
0x656,
0x657,
0x658,
0x659,
0x65A,
0x65B,
0x65C,
0x65D,
0x65E,
0x670,
0x6D6,
0x6D7,
0x6D8,
0x6D9,
0x6DA,
0x6DB,
0x6DC,
0x6DE,
0x6DF,
0x6E0,
0x6E1,
0x6E2,
0x6E3,
0x6E4,
0x6E7,
0x6E8,
0x6EA,
0x6EB,
0x6EC,
0x6ED,
0x711,
0x730,
0x731,
0x732,
0x733,
0x734,
0x735,
0x736,
0x737,
0x738,
0x739,
0x73A,
0x73B,
0x73C,
0x73D,
0x73E,
0x73F,
0x740,
0x741,
0x742,
0x743,
0x744,
0x745,
0x746,
0x747,
0x748,
0x749,
0x74A,
0x7A6,
0x7A7,
0x7A8,
0x7A9,
0x7AA,
0x7AB,
0x7AC,
0x7AD,
0x7AE,
0x7AF,
0x7B0,
0x7EB,
0x7EC,
0x7ED,
0x7EE,
0x7EF,
0x7F0,
0x7F1,
0x7F2,
0x7F3,
0x816,
0x817,
0x818,
0x819,
0x81B,
0x81C,
0x81D,
0x81E,
0x81F,
0x820,
0x821,
0x822,
0x823,
0x825,
0x826,
0x827,
0x829,
0x82A,
0x82B,
0x82C,
0x82D,
0x900,
0x901,
0x902,
0x93C,
0x941,
0x942,
0x943,
0x944,
0x945,
0x946,
0x947,
0x948,
0x94D,
0x951,
0x952,
0x953,
0x954,
0x955,
0x962,
0x963,
0x981,
0x9BC,
0x9BE,
0x9C1,
0x9C2,
0x9C3,
0x9C4,
0x9CD,
0x9D7,
0x9E2,
0x9E3,
0xA01,
0xA02,
0xA3C,
0xA41,
0xA42,
0xA47,
0xA48,
0xA4B,
0xA4C,
0xA4D,
0xA51,
0xA70,
0xA71,
0xA75,
0xA81,
0xA82,
0xABC,
0xAC1,
0xAC2,
0xAC3,
0xAC4,
0xAC5,
0xAC7,
0xAC8,
0xACD,
0xAE2,
0xAE3,
0xB01,
0xB3C,
0xB3E,
0xB3F,
0xB41,
0xB42,
0xB43,
0xB44,
0xB4D,
0xB56,
0xB57,
0xB62,
0xB63,
0xB82,
0xBBE,
0xBC0,
0xBCD,
0xBD7,
0xC3E,
0xC3F,
0xC40,
0xC46,
0xC47,
0xC48,
0xC4A,
0xC4B,
0xC4C,
0xC4D,
0xC55,
0xC56,
0xC62,
0xC63,
0xCBC,
0xCBF,
0xCC2,
0xCC6,
0xCCC,
0xCCD,
0xCD5,
0xCD6,
0xCE2,
0xCE3,
0xD3E,
0xD41,
0xD42,
0xD43,
0xD44,
0xD4D,
0xD57,
0xD62,
0xD63,
0xDCA,
0xDCF,
0xDD2,
0xDD3,
0xDD4,
0xDD6,
0xDDF,
0xE31,
0xE34,
0xE35,
0xE36,
0xE37,
0xE38,
0xE39,
0xE3A,
0xE47,
0xE48,
0xE49,
0xE4A,
0xE4B,
0xE4C,
0xE4D,
0xE4E,
0xEB1,
0xEB4,
0xEB5,
0xEB6,
0xEB7,
0xEB8,
0xEB9,
0xEBB,
0xEBC,
0xEC8,
0xEC9,
0xECA,
0xECB,
0xECC,
0xECD,
0xF18,
0xF19,
0xF35,
0xF37,
0xF39,
0xF71,
0xF72,
0xF73,
0xF74,
0xF75,
0xF76,
0xF77,
0xF78,
0xF79,
0xF7A,
0xF7B,
0xF7C,
0xF7D,
0xF7E,
0xF80,
0xF81,
0xF82,
0xF83,
0xF84,
0xF86,
0xF87,
0xF90,
0xF91,
0xF92,
0xF93,
0xF94,
0xF95,
0xF96,
0xF97,
0xF99,
0xF9A,
0xF9B,
0xF9C,
0xF9D,
0xF9E,
0xF9F,
0xFA0,
0xFA1,
0xFA2,
0xFA3,
0xFA4,
0xFA5,
0xFA6,
0xFA7,
0xFA8,
0xFA9,
0xFAA,
0xFAB,
0xFAC,
0xFAD,
0xFAE,
0xFAF,
0xFB0,
0xFB1,
0xFB2,
0xFB3,
0xFB4,
0xFB5,
0xFB6,
0xFB7,
0xFB8,
0xFB9,
0xFBA,
0xFBB,
0xFBC,
0xFC6,
0x102D,
0x102E,
0x102F,
0x1030,
0x1032,
0x1033,
0x1034,
0x1035,
0x1036,
0x1037,
0x1039,
0x103A,
0x103D,
0x103E,
0x1058,
0x1059,
0x105E,
0x105F,
0x1060,
0x1071,
0x1072,
0x1073,
0x1074,
0x1082,
0x1085,
0x1086,
0x108D,
0x109D,
0x135F,
0x1712,
0x1713,
0x1714,
0x1732,
0x1733,
0x1734,
0x1752,
0x1753,
0x1772,
0x1773,
0x17B7,
0x17B8,
0x17B9,
0x17BA,
0x17BB,
0x17BC,
0x17BD,
0x17C6,
0x17C9,
0x17CA,
0x17CB,
0x17CC,
0x17CD,
0x17CE,
0x17CF,
0x17D0,
0x17D1,
0x17D2,
0x17D3,
0x17DD,
0x180B,
0x180C,
0x180D,
0x18A9,
0x1920,
0x1921,
0x1922,
0x1927,
0x1928,
0x1932,
0x1939,
0x193A,
0x193B,
0x1A17,
0x1A18,
0x1A56,
0x1A58,
0x1A59,
0x1A5A,
0x1A5B,
0x1A5C,
0x1A5D,
0x1A5E,
0x1A60,
0x1A62,
0x1A65,
0x1A66,
0x1A67,
0x1A68,
0x1A69,
0x1A6A,
0x1A6B,
0x1A6C,
0x1A73,
0x1A74,
0x1A75,
0x1A76,
0x1A77,
0x1A78,
0x1A79,
0x1A7A,
0x1A7B,
0x1A7C,
0x1A7F,
0x1B00,
0x1B01,
0x1B02,
0x1B03,
0x1B34,
0x1B36,
0x1B37,
0x1B38,
0x1B39,
0x1B3A,
0x1B3C,
0x1B42,
0x1B6B,
0x1B6C,
0x1B6D,
0x1B6E,
0x1B6F,
0x1B70,
0x1B71,
0x1B72,
0x1B73,
0x1B80,
0x1B81,
0x1BA2,
0x1BA3,
0x1BA4,
0x1BA5,
0x1BA8,
0x1BA9,
0x1C2C,
0x1C2D,
0x1C2E,
0x1C2F,
0x1C30,
0x1C31,
0x1C32,
0x1C33,
0x1C36,
0x1C37,
0x1CD0,
0x1CD1,
0x1CD2,
0x1CD4,
0x1CD5,
0x1CD6,
0x1CD7,
0x1CD8,
0x1CD9,
0x1CDA,
0x1CDB,
0x1CDC,
0x1CDD,
0x1CDE,
0x1CDF,
0x1CE0,
0x1CE2,
0x1CE3,
0x1CE4,
0x1CE5,
0x1CE6,
0x1CE7,
0x1CE8,
0x1CED,
0x1DC0,
0x1DC1,
0x1DC2,
0x1DC3,
0x1DC4,
0x1DC5,
0x1DC6,
0x1DC7,
0x1DC8,
0x1DC9,
0x1DCA,
0x1DCB,
0x1DCC,
0x1DCD,
0x1DCE,
0x1DCF,
0x1DD0,
0x1DD1,
0x1DD2,
0x1DD3,
0x1DD4,
0x1DD5,
0x1DD6,
0x1DD7,
0x1DD8,
0x1DD9,
0x1DDA,
0x1DDB,
0x1DDC,
0x1DDD,
0x1DDE,
0x1DDF,
0x1DE0,
0x1DE1,
0x1DE2,
0x1DE3,
0x1DE4,
0x1DE5,
0x1DE6,
0x1DFD,
0x1DFE,
0x1DFF,
0x200C,
0x200D,
0x20D0,
0x20D1,
0x20D2,
0x20D3,
0x20D4,
0x20D5,
0x20D6,
0x20D7,
0x20D8,
0x20D9,
0x20DA,
0x20DB,
0x20DC,
0x20DD,
0x20DE,
0x20DF,
0x20E0,
0x20E1,
0x20E2,
0x20E3,
0x20E4,
0x20E5,
0x20E6,
0x20E7,
0x20E8,
0x20E9,
0x20EA,
0x20EB,
0x20EC,
0x20ED,
0x20EE,
0x20EF,
0x20F0,
0x2CEF,
0x2CF0,
0x2CF1,
0x2DE0,
0x2DE1,
0x2DE2,
0x2DE3,
0x2DE4,
0x2DE5,
0x2DE6,
0x2DE7,
0x2DE8,
0x2DE9,
0x2DEA,
0x2DEB,
0x2DEC,
0x2DED,
0x2DEE,
0x2DEF,
0x2DF0,
0x2DF1,
0x2DF2,
0x2DF3,
0x2DF4,
0x2DF5,
0x2DF6,
0x2DF7,
0x2DF8,
0x2DF9,
0x2DFA,
0x2DFB,
0x2DFC,
0x2DFD,
0x2DFE,
0x2DFF,
0x302A,
0x302B,
0x302C,
0x302D,
0x302E,
0x302F,
0x3099,
0x309A,
0xA66F,
0xA670,
0xA671,
0xA672,
0xA67C,
0xA67D,
0xA6F0,
0xA6F1,
0xA802,
0xA806,
0xA80B,
0xA825,
0xA826,
0xA8C4,
0xA8E0,
0xA8E1,
0xA8E2,
0xA8E3,
0xA8E4,
0xA8E5,
0xA8E6,
0xA8E7,
0xA8E8,
0xA8E9,
0xA8EA,
0xA8EB,
0xA8EC,
0xA8ED,
0xA8EE,
0xA8EF,
0xA8F0,
0xA8F1,
0xA926,
0xA927,
0xA928,
0xA929,
0xA92A,
0xA92B,
0xA92C,
0xA92D,
0xA947,
0xA948,
0xA949,
0xA94A,
0xA94B,
0xA94C,
0xA94D,
0xA94E,
0xA94F,
0xA950,
0xA951,
0xA980,
0xA981,
0xA982,
0xA9B3,
0xA9B6,
0xA9B7,
0xA9B8,
0xA9B9,
0xA9BC,
0xAA29,
0xAA2A,
0xAA2B,
0xAA2C,
0xAA2D,
0xAA2E,
0xAA31,
0xAA32,
0xAA35,
0xAA36,
0xAA43,
0xAA4C,
0xAAB0,
0xAAB2,
0xAAB3,
0xAAB4,
0xAAB7,
0xAAB8,
0xAABE,
0xAABF,
0xAAC1,
0xABE5,
0xABE8,
0xABED,
0xFB1E,
0xFE00,
0xFE01,
0xFE02,
0xFE03,
0xFE04,
0xFE05,
0xFE06,
0xFE07,
0xFE08,
0xFE09,
0xFE0A,
0xFE0B,
0xFE0C,
0xFE0D,
0xFE0E,
0xFE0F,
0xFE20,
0xFE21,
0xFE22,
0xFE23,
0xFE24,
0xFE25,
0xFE26,
0xFF9E,
0xFF9F,
0x101FD,
0x10A01,
0x10A02,
0x10A03,
0x10A05,
0x10A06,
0x10A0C,
0x10A0D,
0x10A0E,
0x10A0F,
0x10A38,
0x10A39,
0x10A3A,
0x10A3F,
0x11080,
0x11081,
0x110B3,
0x110B4,
0x110B5,
0x110B6,
0x110B9,
0x110BA,
0x1D165,
0x1D167,
0x1D168,
0x1D169,
0x1D16E,
0x1D16F,
0x1D170,
0x1D171,
0x1D172,
0x1D17B,
0x1D17C,
0x1D17D,
0x1D17E,
0x1D17F,
0x1D180,
0x1D181,
0x1D182,
0x1D185,
0x1D186,
0x1D187,
0x1D188,
0x1D189,
0x1D18A,
0x1D18B,
0x1D1AA,
0x1D1AB,
0x1D1AC,
0x1D1AD,
0x1D242,
0x1D243,
0x1D244,
0xE0100,
0xE0101,
0xE0102,
0xE0103,
0xE0104,
0xE0105,
0xE0106,
0xE0107,
0xE0108,
0xE0109,
0xE010A,
0xE010B,
0xE010C,
0xE010D,
0xE010E,
0xE010F,
0xE0110,
0xE0111,
0xE0112,
0xE0113,
0xE0114,
0xE0115,
0xE0116,
0xE0117,
0xE0118,
0xE0119,
0xE011A,
0xE011B,
0xE011C,
0xE011D,
0xE011E,
0xE011F,
0xE0120,
0xE0121,
0xE0122,
0xE0123,
0xE0124,
0xE0125,
0xE0126,
0xE0127,
0xE0128,
0xE0129,
0xE012A,
0xE012B,
0xE012C,
0xE012D,
0xE012E,
0xE012F,
0xE0130,
0xE0131,
0xE0132,
0xE0133,
0xE0134,
0xE0135,
0xE0136,
0xE0137,
0xE0138,
0xE0139,
0xE013A,
0xE013B,
0xE013C,
0xE013D,
0xE013E,
0xE013F,
0xE0140,
0xE0141,
0xE0142,
0xE0143,
0xE0144,
0xE0145,
0xE0146,
0xE0147,
0xE0148,
0xE0149,
0xE014A,
0xE014B,
0xE014C,
0xE014D,
0xE014E,
0xE014F,
0xE0150,
0xE0151,
0xE0152,
0xE0153,
0xE0154,
0xE0155,
0xE0156,
0xE0157,
0xE0158,
0xE0159,
0xE015A,
0xE015B,
0xE015C,
0xE015D,
0xE015E,
0xE015F,
0xE0160,
0xE0161,
0xE0162,
0xE0163,
0xE0164,
0xE0165,
0xE0166,
0xE0167,
0xE0168,
0xE0169,
0xE016A,
0xE016B,
0xE016C,
0xE016D,
0xE016E,
0xE016F,
0xE0170,
0xE0171,
0xE0172,
0xE0173,
0xE0174,
0xE0175,
0xE0176,
0xE0177,
0xE0178,
0xE0179,
0xE017A,
0xE017B,
0xE017C,
0xE017D,
0xE017E,
0xE017F,
0xE0180,
0xE0181,
0xE0182,
0xE0183,
0xE0184,
0xE0185,
0xE0186,
0xE0187,
0xE0188,
0xE0189,
0xE018A,
0xE018B,
0xE018C,
0xE018D,
0xE018E,
0xE018F,
0xE0190,
0xE0191,
0xE0192,
0xE0193,
0xE0194,
0xE0195,
0xE0196,
0xE0197,
0xE0198,
0xE0199,
0xE019A,
0xE019B,
0xE019C,
0xE019D,
0xE019E,
0xE019F,
0xE01A0,
0xE01A1,
0xE01A2,
0xE01A3,
0xE01A4,
0xE01A5,
0xE01A6,
0xE01A7,
0xE01A8,
0xE01A9,
0xE01AA,
0xE01AB,
0xE01AC,
0xE01AD,
0xE01AE,
0xE01AF,
0xE01B0,
0xE01B1,
0xE01B2,
0xE01B3,
0xE01B4,
0xE01B5,
0xE01B6,
0xE01B7,
0xE01B8,
0xE01B9,
0xE01BA,
0xE01BB,
0xE01BC,
0xE01BD,
0xE01BE,
0xE01BF,
0xE01C0,
0xE01C1,
0xE01C2,
0xE01C3,
0xE01C4,
0xE01C5,
0xE01C6,
0xE01C7,
0xE01C8,
0xE01C9,
0xE01CA,
0xE01CB,
0xE01CC,
0xE01CD,
0xE01CE,
0xE01CF,
0xE01D0,
0xE01D1,
0xE01D2,
0xE01D3,
0xE01D4,
0xE01D5,
0xE01D6,
0xE01D7,
0xE01D8,
0xE01D9,
0xE01DA,
0xE01DB,
0xE01DC,
0xE01DD,
0xE01DE,
0xE01DF,
0xE01E0,
0xE01E1,
0xE01E2,
0xE01E3,
0xE01E4,
0xE01E5,
0xE01E6,
0xE01E7,
0xE01E8,
0xE01E9,
0xE01EA,
0xE01EB,
0xE01EC,
0xE01ED,
0xE01EE,
0xE01EF
]; |
import React, { useState } from 'react'
import Radio from '../index'
import {
customDatas,
} from './data'
const Demo = () => {
const [disable, setDisable] = useState(false)
const [defValue, setDefValue] = useState(1)
const handleValue = (v)=> {
console.log('test data: ', v)
}
const handlesubmit = () => {
setDisable(true)
}
const setDefValue2 = () => {
setDefValue(2)
}
const radioProps = {
onClick: handleValue,
itemStyle: { borderRadius: '5px'},
itemClass: 'atest',
disabled: disable,
datas: customDatas,
defValue,
}
return (
<React.Fragment>
<Radio onClick={handleValue} layout={2} />
<Radio {...radioProps} />
<button onClick={handlesubmit}>提交</button>
<button onClick={setDefValue2}>提交</button>
</React.Fragment>
)
}
export default Demo |
import ApiService from '../../../services/Api'
import { reset } from 'redux-form'
import { fetchHouseholdsComplete } from '../Households/actions'
import { fetchMealsComplete } from '../Meals/actions'
import { showLoading, hideLoading } from 'react-redux-loading-bar'
export const authenticating = () => ({ type: 'AUTHENTICATING' })
export const setUser = user => ({ type: 'AUTH_COMPLETE', user })
export const authenticationFailure = errors => ({
type: 'AUTH_FAILURE',
errors,
})
export const logout = router => {
localStorage.removeItem('token')
return { type: 'LOGOUT' }
}
export const apiCall = () => {
return dispatch => {
dispatch({
type: 'APP_LOADING',
})
const householdProm = ApiService.get(`/households`)
const mealProm = ApiService.get(`/meals`)
Promise.all([householdProm, mealProm]).then(values => {
dispatch(fetchHouseholdsComplete(values[0]))
dispatch(fetchMealsComplete(values[1]))
dispatch({ type: 'APP_LOADING_COMPLETE' })
console.log(values)
})
}
}
export const authenticate = () => {
return dispatch => {
dispatch(authenticating())
dispatch(showLoading())
return ApiService.post(`/auth/refresh`).then(currentUser => {
const { user, token } = currentUser
localStorage.setItem('token', JSON.stringify(token))
dispatch(hideLoading())
dispatch(setUser(user))
})
}
}
export const signup = (data, history) => {
return dispatch => {
dispatch(authenticating())
ApiService.post('/users', data)
.then(currentUser => {
const { user, token } = currentUser
localStorage.setItem('token', JSON.stringify(token))
dispatch(setUser(user))
dispatch(reset('signup'))
history.replace('/')
})
.catch(err => {
dispatch({ type: 'ERROR_MESSAGE', payload: err })
})
}
}
export const login = (params, history) => {
return dispatch => {
dispatch(authenticating())
ApiService.post('/auth', params)
.then(currentUser => {
const { user, token } = currentUser
localStorage.setItem('token', JSON.stringify(token))
dispatch(setUser(user))
dispatch(reset('login'))
history.replace('/households')
})
.catch(err => {
dispatch({ type: 'ERROR_MESSAGE', payload: err.message })
})
}
}
|
var class_yeah_1_1_fw_1_1_html_components_1_1_combo_box_html_component =
[
[ "render", "class_yeah_1_1_fw_1_1_html_components_1_1_combo_box_html_component.html#a8c860bd0c556ae563b3a543aaadb1e82", null ]
]; |
var inquirer = require('../util/Inquirer.js')
, chalk = require ('chalk')
, config = require('./config')
, edit_diary = require('./crud')
, date = require('./convertdate')
, encryption = require('./encryption')
, colors = require ('./writecolor')
, write = colors.current_theme();
var submission = [{
type: "input",
name: "submission",
message: "write your thoughts below..\n",
validate: function(str){
var entry = str.trim();
return entry !== '';
}
}];
var select = [{
type: "input",
name: "submission",
message: "what would you like to see?\n type in a date or press enter to view all \n"
}];
var check = [{
type: "password",
name: "login",
message: "enter your password to continue",
validate: function(str){
return str !== '';
}
}];
var confirm = [{
type: "confirm",
name: "confirm_delete",
message: "are you sure you'd like to delete your last entry?",
default: false
}];
var submit = function(){
inquirer.prompt(submission, function(answer){
var new_entry = encryption.encrypt(answer.submission);
edit_diary.new_entry(new_entry);
write.log('thanks for sharing ' + config.name());
});
};
var read = function(){
inquirer.prompt(select, function(answer) {
var submission = date(answer.submission);
switch (submission[1]) {
case 'last':
edit_diary.find_last(edit_diary.show_last);
return;
case 'chunk' :
edit_diary.find_chunk(submission[0]);
return;
case 'date' :
edit_diary.find_entry(submission[0]);
return;
default :
write.log('no submissions for that day..')
}
write.emphasis('please enter a valid date format...');
});
};
var burn = function(){
inquirer.prompt(confirm, function(answer){
if ( answer.confirm_delete) {
write.log('as if it never existed');
edit_diary.find_last(edit_diary.delete_last);
}
})
};
var validation = function(action1, action2){
if (! config.checkconfig()) {
inquirer.prompt(check, function ( answer ) {
if (config.compare("password", answer.login)){
write.log('~unlocked~');
action1();
} else {
unauthorized();
}
})
} else {
action2();
}
};
var unauthorized = function(){
write.log(config.name() +", is that you??...Enter " + chalk.inverse("<<dear-diary change password>>") + " if you need to reset your password. ")
};
var notifysetup = function(){
write.log("hmmm...you need to configure your diary first. Enter" + chalk.inverse("<<dear-diary setup>>") + " to get started");
};
module.exports.validation = validation;
module.exports.unauthorized = unauthorized;
module.exports.notifysetup = notifysetup;
module.exports.submit = submit;
module.exports.read = read;
module.exports.burn = burn; |
import { Services } from 'urbano'
'use strict'
class dflt extends Services {
}
export default dflt
|
var LogoutCtrl = function($scope, $state, AuthService, BungieService) {
AuthService.logout().then(function() {
BungieService.reset();
location.reload();
})
};
angular
.module('app.auth')
.controller('LogoutCtrl', ['$scope', '$state', 'AuthService', 'BungieService', LogoutCtrl]);
|
"use strict";
define(["res", "system-common"], function (res, common) {
var z_init = {
prop: {
数字: 0,
模拟: 0,
焊接: 0,
论文: 0,
声望: 0,
道德: 0,
秩序: 0
},
uid: 0, //unique id
power: 8,
powerMax: 10,
basic: {
name: "李厷叺",
title: "麻瓜",
test: 0,
money: 1000,
sex: "male"
},
time: {
year: 2014,
term: 1,
month: 9,
round: 2,
week: 1,
week_day_index: 5,
day: 1,
period: 0,
total_point: 3,
total_point_today: 3
},
experience: {
OI: false,
phy: false,
math: false,
axe: false
},
plot: {
xuanjianghui: false,
kexie_first: false
},
amity: {},
skill: {},
item: {},
device: {},
components: {},
character: {},
game: {
move: 1,
increase: 1.2
}
};
for (var i in res.skills) {
z_init.skill[i] = {
level: 0
};
}
for (var i in res.pp) {
z_init.amity[i] = 0;
}
for (var i in res.items) {
z_init.item[i] = {
cnt: 0
};
}
for (var i in res.devices) {
z_init.device[i] = {
cnt: 0
};
}
var z = common.clone(z_init);
common.setZ(z);
var works = {
硬件流水灯: {
1: {
id: common.getUid(),
name: "硬件流水灯",
prefix: {
feature: "幸运",
basic: "未完成"
},
process: {
basic: 3,
basicMax: 10,
capability: 0,
capabilityMax: 5,
innovation: 0,
innovationMax: 3,
stability: 0,
stabilityMax: 10
},
phase: "making",
props: [0, 100, 0],
property: [{
kind: "lucky",
value: "3"
}]
}
}
};
z.work = works;
return z;
}); |
const { argv } = require('yargs')
.option('platform', {
describe: 'The documentation platform.',
type: 'string',
demandOption: true,
})
.option('source', {
describe: 'Relative local build location.',
type: 'string',
demandOption: true,
})
.option('host', {
describe: 'The host to connect to',
type: 'string',
demandOption: true,
})
.option('port', {
describe: 'The port used for the connection',
type: 'number',
demandOption: true,
})
.option('serverPath', {
describe: 'Full absolute server path.',
type: 'string',
demandOption: true,
})
.option('username', {
describe: 'SFTP username',
type: 'string',
demandOption: true,
})
.option('password', {
describe: 'SFTP password.',
type: 'string',
demandOption: false,
})
.option('privateKey', {
describe: 'SSH key.',
type: 'string',
demandOption: false,
});
const fs = require('fs');
const path = require('path');
const chalk = require('chalk');
const { Client } = require('ssh2');
const { version } = require('../../package.json');
const {
asyncForEach,
connectToServer,
createDirectory,
createSftpConnection,
getFiles,
readDirectory,
uploadFile,
} = require('./deploy-utils');
const client = new Client();
const { platform, source, host, port, serverPath, username, privateKey, password } = argv;
(async () => {
const target = `${serverPath}/${platform}/${version}`;
await connectToServer(client, {
host,
port,
username,
password,
privateKey: Buffer.from(privateKey, 'base64'),
});
const sftp = await createSftpConnection(client);
const list = await readDirectory(sftp, target);
// TODO: We might need to be able to overwrite a build without manual removal
if (list)
return Promise.reject(
`The directory (${target}) is not empty, aborting to avoid overwriting...`,
);
await createDirectory(sftp, target);
const files = await getFiles(`${source}/**/*`);
await asyncForEach(files, async file => {
const fileSource = path.resolve(file);
const fileTarget = path.resolve(`${target}/${file.replace(source, '')}`);
// Create the folder on the server if we reach a directory
if (fs.statSync(fileSource).isDirectory()) {
return createDirectory(sftp, fileTarget);
}
// Upload the file to the server
return uploadFile(sftp, fileSource, fileTarget);
});
})()
.then(() => {
console.log(`🎉 ${platform} have been generated and uploaded to: ${chalk.bold(`version ${version}`)}`);
client.end();
})
.catch(error => {
console.log(chalk.red(error));
client.end();
});
|
$('.form').find('input, textarea').on('keyup blur focus', function (e) {
var $this = $(this),
label = $this.prev('label');
if (e.type === 'keyup') {
if ($this.val() === '') {
label.removeClass('active highlight');
} else {
label.addClass('active highlight');
}
} else if (e.type === 'blur') {
if ($this.val() === '') {
label.removeClass('active highlight');
} else {
label.removeClass('highlight');
}
} else if (e.type === 'focus') {
if ($this.val() === '') {
label.removeClass('highlight');
}
else if ($this.val() !== '') {
label.addClass('highlight');
}
}
});
$('.tab a').on('click', function (e) {
e.preventDefault();
$(this).parent().addClass('active');
$(this).parent().siblings().removeClass('active');
target = $(this).attr('href');
$('.tab-content > div').not(target).hide();
$(target).fadeIn(600);
}); |
'use strict';
module.exports = function (grunt) {
require('load-grunt-tasks')(grunt);
// Configurable paths
var config = {
app: 'app'
};
grunt.initConfig({
config: config,
// Watches files for changes and runs tasks based on the changed files
watch: {
js: {
files: ['<%= config.app %>/scripts/{,*/}*.js'],
tasks: ['jshint']
},
gruntfile: {
files: ['Gruntfile.js']
},
sass: {
files: ['<%= config.app %>/styles/{,*/}*.{scss,sass}'],
tasks: ['sass:server']
},
styles: {
files: ['<%= config.app %>/styles/{,*/}*.css'],
tasks: ['newer:copy:styles']
}
},
// Copies remaining files to places other tasks can use
copy: {
styles: {
expand: true,
dot: true,
cwd: '<%= config.app %>/styles',
dest: '.tmp/styles/',
src: '{,*/}*.css'
}
},
// The actual grunt server settings
connect: {
server: {
options: {
port: 14000,
base: '<%= config.app %>',
}
}
},
// Empties folders to start fresh
clean: {
server: '.tmp'
},
// Run some tasks in parallel to speed up build process
concurrent: {
server: [
'sass:server',
'copy:styles'
]
},
// Make sure code styles are up to par and there are no obvious mistakes
jshint: {
options: {
jshintrc: '.jshintrc',
reporter: require('jshint-stylish')
},
all: [
'Gruntfile.js',
'<%= config.app %>/scripts/{,*/}*.js',
'!<%= config.app %>/scripts/vendor/*',
]
},
// Compiles Sass to CSS and generates necessary files if requested
sass: {
options: {
includePaths: [
'bower_components'
]
},
server: {
files: [{
expand: true,
cwd: '<%= config.app %>/styles',
src: ['*.scss'],
dest: '.tmp/styles',
ext: '.css'
}]
}
},
});
grunt.registerTask('serve', function(target) {
grunt.task.run([
'clean:server',
'concurrent:server',
'connect:server',
'watch'
]);
});
}; |
fnc.uiControls.panels.wrappanel = (function () {
var panel = fnc.uiControls.panels.panel;
var wrappanel = function (name, publicProperties, privateProperties) {
this.initialize(name, publicProperties, privateProperties);
this.tag = "wrappanel";
}
var placeChildrenInsideWrapPanel = function() {
var currentLeft = 0;
var currentTop = 0;
var maxHeight = 0;
var panelHeight = 0;
var panelWidth = this.properties['width'] || null;
for(var i= 0, child; child=this.children.get(i); i++) {
var style = child.dom.style;
var width = parseInt(style.width.slice(0, -2));
var height = parseInt(style.height.slice(0, -2));
if (panelWidth && (currentLeft + width) > parseInt(panelWidth)) {
currentLeft = 0;
currentTop = currentTop + maxHeight;
maxHeight = height;
} else {
if(height > maxHeight) {
maxHeight = height;
}
}
style.left = currentLeft + 'px';
style.top = currentTop + 'px';
currentLeft = currentLeft + width;
}
this.dom.style.width = (currentLeft > this.width ? currentLeft : this.width) + 'px';
var newHeight = (currentTop + maxHeight);
this.dom.style.height = (newHeight > this.height ? newHeight : this.height) + 'px';
}
wrappanel.prototype = new panel();
wrappanel.prototype.render = function(options) {
//create this.dom as per parent
panel.prototype.render.call(this, options);
this.renderChildren({available_height: parseInt(this.dom.style.height), available_width: parseInt(this.dom.style.width)});
placeChildrenInsideWrapPanel.call(this);
return this.dom;
};
return wrappanel;
})();
|
var roundtrip = require('../../util/roundtrip')
, assert = require('../../assert/roundtrip');
describe('jsr-rdb (parser)', function() {
it('should load and save 32 bit integer value', function(done) {
roundtrip('integer-32.rdb', assert(done));
});
});
|
'use strict';
const User = require('../models/user');
const Material = require('../models/material');
module.exports = {
users: require('./users')(User),
materials: require('./materials')(Material)
} |
'use strict';
describe('Service: IndexService', function () {
// load the service's module
beforeEach(module('getAgileApp'));
// instantiate service
var IndexService;
beforeEach(inject(function (_IndexService_) {
IndexService = _IndexService_;
}));
it('should do something', function () {
expect(!!IndexService).toBe(true);
});
});
|
/**
* PriorityQueue
* Elements in this queue are sorted according to their value
*
* @author Lukasz Krawczyk <contact@lukaszkrawczyk.eu>
* @copyright MIT
*/
/**
* PriorityQueue class construcotr
* @constructor
*
* @example
* queue: [1,2,3,4]
* priorities: [4,1,2,3]
* > result = [1,4,2,3]
*
* @param {Array} elements
* @param {Array} priorities
* @param {string} sorting - asc / desc
* @returns {PriorityQueue}
*/
function PriorityQueue(elements, priorities, sorting) {
/** @type {Array} */
this._queue = [];
/** @type {Array} */
this._priorities = [];
/** @type {string} */
this._sorting = 'desc';
this._init(elements, priorities, sorting);
}
;
/**
* Insert element
*
* @param {Object} ele
* @param {Object} priority
* @returns {undefined}
* @access public
*/
PriorityQueue.prototype.insert = function (ele, priority) {
var indexToInsert = this._queue.length;
var index = indexToInsert;
while (index--) {
var priority2 = this._priorities[index];
if (this._sorting === 'desc') {
if (priority > priority2) {
indexToInsert = index;
}
}
else {
if (priority < priority2) {
indexToInsert = index;
}
}
}
this._insertAt(ele, priority, indexToInsert);
};
/**
* Remove element
*
* @param {Object} ele
* @returns {undefined}
* @access public
*/
PriorityQueue.prototype.remove = function (ele) {
var index = this._queue.length;
while (index--) {
var ele2 = this._queue[index];
if (ele === ele2) {
this._queue.splice(index, 1);
this._priorities.splice(index, 1);
break;
}
}
};
/**
* For each loop wrapper
*
* @param {function} func
* @returs {undefined}
* @access public
*/
PriorityQueue.prototype.forEach = function (func) {
this._queue.forEach(func);
};
/**
* @returns {Array}
* @access public
*/
PriorityQueue.prototype.getElements = function () {
return this._queue;
};
/**
* @param {number} index
* @returns {Object}
* @access public
*/
PriorityQueue.prototype.getElementPriority = function (index) {
return this._priorities[index];
};
/**
* @returns {Array}
* @access public
*/
PriorityQueue.prototype.getPriorities = function () {
return this._priorities;
};
/**
* @returns {Array}
* @access public
*/
PriorityQueue.prototype.getElementsWithPriorities = function () {
var result = [];
for (var i = 0, l = this._queue.length; i < l; i++) {
result.push([this._queue[i], this._priorities[i]]);
}
return result;
};
/**
* Set object properties
*
* @param {Array} elements
* @param {Array} priorities
* @returns {undefined}
* @access protected
*/
PriorityQueue.prototype._init = function (elements, priorities, sorting) {
if (elements && priorities) {
this._queue = [];
this._priorities = [];
if (elements.length !== priorities.length) {
throw new Error('Arrays must have the same length');
}
for (var i = 0; i < elements.length; i++) {
this.insert(elements[i], priorities[i]);
}
}
if (sorting) {
this._sorting = sorting;
}
};
/**
* Insert element at given position
*
* @param {Object} ele
* @param {number} index
* @returns {undefined}
* @access protected
*/
PriorityQueue.prototype._insertAt = function (ele, priority, index) {
if (this._queue.length === index) {
this._queue.push(ele);
this._priorities.push(priority);
}
else {
this._queue.splice(index, 0, ele);
this._priorities.splice(index, 0, priority);
}
};
if (typeof module !== 'undefined' && module.exports) {
module.exports = PriorityQueue;
}
|
'use strict';
/*
* GET home page.
*/
exports.index = function(req, res){
res.render('index', {
title: 'Express'
});
}; |
/*
* Copyright (c) 2011-2012, Yahoo! Inc. All rights reserved.
* Copyrights licensed under the New BSD License.
* See the accompanying LICENSE file for terms.
*/
var Blob = require('../blob').Blob;
/**
* Appends file contents onto queue.
*
* @param options {Object} File options or filename.
* @param options.name {String} Filename to read.
* @param options.encoding {String} File encoding.
* @param done {Function} Callback on task completion.
*/
exports.read = function(options, done) {
options = (typeof options === 'string') ? {name: options} : options;
var encoding = options.encoding || 'utf8';
Blob.readFile(options.name, encoding, done, options.sync);
}; |
'use strict'
const pinyin = require('./core')
const patcher56L = require('./patchers/56l')
// Patch dict for icudt56l.dat related env, such as safari|node v4.
if (pinyin.isSupported() && patcher56L.shouldPatch(pinyin.genToken)) {
pinyin.patchDict(patcher56L)
}
module.exports = pinyin
|
var path = require('path');
var fs = require('fs');
var express = require('express');
var app = express();
app.get('/books', function (req, res) {
fs.readFile(process.argv[3], function (err, data) {
if (err) {
throw err;
}
object = JSON.parse(data);
res.send(object);
});
});
app.listen(process.argv[2]);
|
const CALL_API = Symbol('Call API');
export default CALL_API;
|
import React from 'react';
import PropTypes from 'prop-types';
import { FormattedMessage } from 'react-intl';
import ValueListCell from './ValueListCell';
export default function ClusterFactCheckedByTeamsCell({ projectMedia }) {
const values = projectMedia.cluster.fact_checked_by_team_names;
return (
<ValueListCell
values={values}
noValueLabel={
<FormattedMessage id="checkedByTeamsCell.noFactCheck" defaultMessage="No fact-check" description="Table cell displayed on Trends page when claim is not fact-checked yet" />
}
randomizeOrder
renderNoValueAsChip
/>
);
}
ClusterFactCheckedByTeamsCell.propTypes = {
projectMedia: PropTypes.shape({
cluster: PropTypes.shape({
fact_checked_by_team_names: PropTypes.arrayOf(PropTypes.string.isRequired).isRequired,
}).isRequired,
}).isRequired,
};
|
import { Slingshot } from 'meteor/edgee:slingshot';
Slingshot.fileRestrictions("assets", {
allowedFileTypes: ["image/png", "image/jpeg", "image/gif"],
maxSize: 10 * 1024 * 1024 // 10 MB (use null for unlimited).
});
Slingshot.fileRestrictions("profile", {
allowedFileTypes: ["image/png", "image/jpeg", "image/gif"],
maxSize: 1024 * 1024 // 1 MB (use null for unlimited).
}); |
System.register(['angular2/core'], function(exports_1, context_1) {
"use strict";
var __moduleName = context_1 && context_1.id;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var core_1;
var ContactHeaderComponent;
return {
setters:[
function (core_1_1) {
core_1 = core_1_1;
}],
execute: function() {
ContactHeaderComponent = (function () {
function ContactHeaderComponent() {
}
ContactHeaderComponent = __decorate([
core_1.Component({
selector: 'contact-header',
template: "\n <div class=\"navbar-fixed\">\n <nav>\n <div class=\"nav-wrapper\">\n <span class=\"brand-logo center\">Contacts</span>\n </div>\n </nav>\n </div>"
}),
__metadata('design:paramtypes', [])
], ContactHeaderComponent);
return ContactHeaderComponent;
}());
exports_1("ContactHeaderComponent", ContactHeaderComponent);
}
}
});
//# sourceMappingURL=contact-header-component.js.map |
/*
* WebGLHelper
* 管理WebGL的辅助对象
*/
var WebGLHelper = {
/* 根据ID定位DOM元素 */
$ : function(id){
return typeof id == 'string' ? document.getElementById(id) : id;
},
/* 获取canvas标记的WebGL对象 */
$$ : function(canvas){
if(!(canvas = this.$(canvas))
|| canvas.nodeType != 1
|| canvas.nodeName.toLowerCase() != 'canvas'
){
return null;
} else {
try{
return canvas.getContext('experimental-webgl');
} catch(ex){ return null; }
}
},
/* 获取script标记中的代码 */
getShaderScript : function(script){
if(!(script = this.$(script))) return null;
var source = '', child = script.firstChild;
while(!!child){
if(child.nodeType == 3){
source += child.textContent;
}
child = child.nextSibling;
}
child = script = null;
return source;
},
/* 获取所有x-shader代码节点 */
allScripts : function(){
var arr = [], els = document.getElementsByTagName('script'), i = 0, len = els.length;
for(; i < len; i++){
if(!!els[i].type && els[i].type.toLowerCase().indexOf('x-shader/') >= 0){
arr.push(els[i]);
}
}
els = i = len = null;
if(arr.length < 1){
return arr = null
} else {
return arr;
}
},
/*
* 从所有代码节点中理出vertex和fragment两种代码
* 返回一个对象{ vs:string, fs:string }
* 如果有两个相同type的shader-script,较靠后的节点的内容会作为最终赋值
*/
documentShaders : function(){
var scripts = this.allScripts(), i = 0, len = scripts.length
shaders = {};
;
for(; i < len; i++){
switch(scripts[i].type){
case 'x-shader/x-fragment':
shaders.fs = this.getShaderScript(scripts[i]);
break;
case 'x-shader/x-vertex':
shaders.vs = this.getShaderScript(scripts[i]);
break;
}
}
return shaders;
}
}
/* 场景设置对象 */
function MatrixHelper(gl, prog){
this.gl = gl;
this.prog = prog;
this.matrix = Matrix.I(4);
}
MatrixHelper.prototype = {
/* makePerspective */
make : function(fovy, aspect, znear, zfar){
this.ppm = Matrix.makePerspective(fovy, aspect, znear, zfar);
},
/* multMatrix */
mult : function(m){
this.matrix = this.matrix.x(m);
},
/* mvTranslate */
trans : function(v){
this.mult(Matrix.Translation($V([v[0], v[1], v[2]])).ensure4x4());
},
/* setMatrixUniforms */
set : function(){
if(!!this.ppm){
this.gl.uniformMatrix4fv(
this.gl.getUniformLocation(this.prog, "uPMatrix")
, false, new Float32Array(this.ppm.flatten())
);
}
if(!!this.matrix){
this.gl.uniformMatrix4fv(
this.gl.getUniformLocation(this.prog, "uMVMatrix")
, false, new Float32Array(this.matrix.flatten())
);
}
},
/* mvRotate */
rotate : function(angle, v){
var m = Matrix.Rotation(angle * Math.PI / 180.0, $V([v[0], v[1], v[2]])).ensure4x4();
this.mult(m);
}
}
/*
* iWebGL
* 构造函数动态接收参数
* 参数为一个时,认为该参数为canvas对象或者对象的id,并调用init方法初始化gl属性和program属性
* 多于一个时,后面的参数将被传递到clear方法
*/
function iWebGL(){
var args = Array.prototype.slice.call(arguments, 0), id = args.shift();
this.init(id);
if(args.length > 0){
this.clear.apply(this, args);
}
args = null;
}
iWebGL.prototype = {
/* 返回WebGL对象的canvas容器 */
canvas : function(){
return !this.gl ? null : this.gl.canvas;
},
/* 返回绘制区域宽度 */
w : function(){
return !this.gl ? -1 : this.gl.drawingBufferWidth;
},
/* 返回绘制区域高度 */
h : function(){
return !this.gl ? -1 : this.gl.drawingBufferHeight;
},
/* 返回绘制区域宽高比率 */
r : function(){
return this.w() / this.h();
},
/* 初始化WebGL/Program/Matrix属性 */
init : function(id){
this.matrix = null;
this.gl = WebGLHelper.$$(id);
if(!!this.gl){
this.matrix = new MatrixHelper(
this.gl,
this.program = this.gl.createProgram()
);
this.shader();
}
},
/* 重置绘图区域颜色/景深/遮挡关系等设置 */
clear : function(){
var args = Array.prototype.slice.call(arguments, 0),
r = args.shift() || 0,
g = args.shift() || 0,
b = args.shift() || 0,
a = args.shift(),
depth = args.shift();
if(typeof a != 'number') a = 1;
if(typeof depth != 'number') depth = 1;
with(this.gl){
clearColor(r, g, b, a);
clearDepth(depth);
enable(DEPTH_TEST);
depthFunc(LEQUAL);
}
args = r = g = b = a = depth = null;
},
/* 刷新显示缓存 */
fresh : function(){
//this.gl.clear(this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT);
this.gl.clear(16640);
},
/*
* 调用Shader脚本
* 可接受参数类型为两种情况
* 1.无参数.这时会在页面中搜寻script标记并加载.
* 2.两个参数,即shader形参形式,分别加载vertex和fragment两种代码字符串
*/
shader : function(vert, frag){
if(arguments.length == 0){
var ss = WebGLHelper.documentShaders();
vert = ss.vs;
frag = ss.fs;
ss = null;
}
if(!!vert && typeof vert == 'string' && !!frag && typeof frag == 'string'){
var _ = this;
with(this.gl){
_.vs = createShader(VERTEX_SHADER);
shaderSource(_.vs, vert);
compileShader(_.vs);
_.fs = createShader(FRAGMENT_SHADER);
shaderSource(_.fs, frag);
compileShader(_.fs);
attachShader(_.program, _.vs);
attachShader(_.program, _.fs);
linkProgram(_.program);
useProgram(_.program);
}
_ = null;
}
},
/* 定位Shaper脚本中变量句柄 */
param : function(argName){
if(!argName || typeof argName != 'string') return;
this.gl.enableVertexAttribArray(
this[argName] = this.gl.getAttribLocation(this.program, argName)
);
},
/*
* 调用param方法定位参数后
* 返回一个传递顶点数据的方法
* 该方法指定了实例中define方法对应定点数据的参数
*/
paramVertices : function(argName){
this.param(argName);
var _ = this;
return {
define : function(data){
_.define(data, _.gl.ARRAY_BUFFER, 'Float32', _.gl.STATIC_DRAW, argName, 3, _.gl.FLOAT);
}
}
},
/*
* 调用param方法定位参数后
* 返回一个传递颜色数据的方法
* 该方法指定了实例中define方法对应颜色数据的参数
*/
paramColors : function(argName){
this.param(argName);
var _ = this;
return {
define : function(data){
_.define(data, _.gl.ARRAY_BUFFER, 'Float32', _.gl.STATIC_DRAW, argName, 4, _.gl.FLOAT);
}
}
},
/*
* 调用param方法定位参数后
* 返回一个传递元素顶点数据的方法
* 该方法指定了实例中define方法对应元素顶点数据的参数
*/
paramVerticesIndex : function(argName){
this.param(argName);
var _ = this;
return {
define : function(data){
_.define(data
, _.gl.ELEMENT_ARRAY_BUFFER
, 'Uint16'
, _.gl.STATIC_DRAW
, argName
, 3
, _.gl.UNSIGNED_SHORT
);
}
}
},
define : function(data, bindType, arrayType, drawType, argName, group, pointerType){
with(this.gl){
bindBuffer(bindType, createBuffer());
bufferData(bindType, new window[arrayType + 'Array'](data), drawType);
if(!!argName && typeof argName == 'string'){
vertexAttribPointer(this[argName], group, pointerType, false, 0, 0);
}
}
},
/*
* 参数化绘制
*/
draw : function(method, drawType, count, dataType){
this.fresh();
this.matrix.set();
this.gl[method](drawType, count, dataType, 0);
},
/* 绘制立方体,调用draw方法并指定绘制的相关参数 */
drawCube : function(){
this.draw('drawElements', 4, 36, 5123, 0);
}
} |
/**
* Created by miralemcebic on 05/02/16.
*/
'use strict';
angular.module('ngsocial.facebook', ['ngRoute', 'ngFacebook'])
.config(['$routeProvider', function($routeProvider) {
$routeProvider.when('/facebook', {
templateUrl: 'facebook/facebook.html',
controller: 'FacebookCtrl'
});
}])
.config(['$facebookProvider', function($facebookProvider) {
$facebookProvider.setAppId('');
$facebookProvider.setPermissions('email, public_profile, user_posts, user_photos, publish_actions');
}])
.run(function( $rootScope ) {
// Cut and paste the "Load the SDK" code from the facebook javascript sdk page.
// Load the facebook SDK asynchronously
(function(d, s, id){
var js, fjs = d.getElementsByTagName(s)[0];
if (d.getElementById(id)) {return;}
js = d.createElement(s); js.id = id;
js.src = "//connect.facebook.net/en_US/sdk.js";
fjs.parentNode.insertBefore(js, fjs);
}(document, 'script', 'facebook-jssdk'));
})
.controller('FacebookCtrl', ['$scope', '$facebook', function($scope, $facebook) {
$scope.isLoggedIn = false;
$scope.login = function() {
$facebook.login().then(function() {
console.log('Logged in');
$scope.isLoggedIn = true;
refresh();
});
}
$scope.logout = function() {
$facebook.logout().then(function() {
console.log('Logged out');
$scope.isLoggedIn = false;
refresh();
});
}
$scope.postStatus = function() {
var myPostTextArea = this.myPostTextArea; // get data from ng-model=myPostTextArea
$facebook.api("/me/feed", 'post', {message: myPostTextArea}).then(function(response){
$scope.msg = "Thanks for posting";
this.myPostTextArea = '';
refresh();
});
}
function refresh() {
$facebook.api("/me").then(function(response){
$scope.welcomeMsg = "Welcome " + response.name;
$scope.isLoggedIn = true;
$scope.userInfo = response;
console.log("userInfo-response " + response)
console.log("userInfo-response: first_name " + response.first_name)
$facebook.api("/me/picture").then(function(respnse){
$scope.picutre = respnse.data.url;
$facebook.api("/me/permissions").then(function(response){
$scope.permissions = response.data;
console.log("permissions-response " + response.data)
$facebook.api("/me/posts").then(function(response) {
$scope.posts = response.data;
console.log("post-response " + response.data)
});
});
});
},
function(error){
$scope.welcomeMsg = "Please Log in";
});
}
refresh();
}]); |
var ajax = require('../lib/Ajax');
module.exports = Ractive.extend({
data: {
value: null,
url: ''
},
fetch: function(cb) {
var self = this;
ajax.request({
url: self.get('url'),
json: true
})
.done(function(result) {
self.set('value', result);
if(cb) {
cb(null, result);
}
})
.fail(function(xhr) {
self.set('value', null);
if(cb) {
cb({ error: 'Error loading ' + self.get('url')});
}
});
return this;
},
create: function(cb) {
var self = this;
ajax.request({
url: self.get('url'),
method: 'POST',
data: this.get('value'),
json: true
})
.done(function(result) {
if(cb) {
cb(null, result);
}
})
.fail(function(xhr) {
if(cb) {
cb(JSON.parse(xhr.responseText));
}
});
return this;
},
save: function(cb) {
var self = this;
ajax.request({
url: self.get('url'),
method: 'PUT',
data: this.get('value'),
json: true
})
.done(function(result) {
if(cb) {
cb(null, result);
}
})
.fail(function(xhr) {
if(cb) {
cb(JSON.parse(xhr.responseText));
}
});
return this;
},
del: function(cb) {
var self = this;
ajax.request({
url: self.get('url'),
method: 'DELETE',
json: true
})
.done(function(result) {
if(cb) {
cb(null, result);
}
})
.fail(function(xhr) {
if(cb) {
cb(JSON.parse(xhr.responseText));
}
});
return this;
},
bindComponent: function(component) {
if(component) {
this.observe('value', function(v) {
for(var key in v) component.set(key, v[key]);
}, { init: false });
}
return this;
},
setter: function(key) {
var self = this;
return function(v) {
self.set(key, v);
}
}
}); |
describe('BrowserStack', function() {
describe('Platform', function() {
require('./browserstack/platform/status')
})
})
|
/**
* Isotope v1.5.21
* An exquisite jQuery plugin for magical layouts
* http://isotope.metafizzy.co
*
* Commercial use requires one-time license fee
* http://metafizzy.co/#licenses
*
* Copyright 2012 David DeSandro / Metafizzy
*/
/*jshint asi: true, browser: true, curly: true, eqeqeq: true, forin: false, immed: false, newcap: true, noempty: true, strict: true, undef: true */
/*global jQuery: false */
(function( window, $, undefined ){
'use strict';
// get global vars
var document = window.document;
var Modernizr = window.Modernizr;
// helper function
var capitalize = function( str ) {
return str.charAt(0).toUpperCase() + str.slice(1);
};
// ========================= getStyleProperty by kangax ===============================
// http://perfectionkills.com/feature-testing-css-properties/
var prefixes = 'Moz Webkit O Ms'.split(' ');
var getStyleProperty = function( propName ) {
var style = document.documentElement.style,
prefixed;
// test standard property first
if ( typeof style[propName] === 'string' ) {
return propName;
}
// capitalize
propName = capitalize( propName );
// test vendor specific properties
for ( var i=0, len = prefixes.length; i < len; i++ ) {
prefixed = prefixes[i] + propName;
if ( typeof style[ prefixed ] === 'string' ) {
return prefixed;
}
}
};
var transformProp = getStyleProperty('transform'),
transitionProp = getStyleProperty('transitionProperty');
// ========================= miniModernizr ===============================
// <3<3<3 and thanks to Faruk and Paul for doing the heavy lifting
/*!
* Modernizr v1.6ish: miniModernizr for Isotope
* http://www.modernizr.com
*
* Developed by:
* - Faruk Ates http://farukat.es/
* - Paul Irish http://paulirish.com/
*
* Copyright (c) 2009-2010
* Dual-licensed under the BSD or MIT licenses.
* http://www.modernizr.com/license/
*/
/*
* This version whittles down the script just to check support for
* CSS transitions, transforms, and 3D transforms.
*/
var tests = {
csstransforms: function() {
return !!transformProp;
},
csstransforms3d: function() {
var test = !!getStyleProperty('perspective');
// double check for Chrome's false positive
if ( test ) {
var vendorCSSPrefixes = ' -o- -moz- -ms- -webkit- -khtml- '.split(' '),
mediaQuery = '@media (' + vendorCSSPrefixes.join('transform-3d),(') + 'modernizr)',
$style = $('<style>' + mediaQuery + '{#modernizr{height:3px}}' + '</style>')
.appendTo('head'),
$div = $('<div id="modernizr" />').appendTo('html');
test = $div.height() === 3;
$div.remove();
$style.remove();
}
return test;
},
csstransitions: function() {
return !!transitionProp;
}
};
var testName;
if ( Modernizr ) {
// if there's a previous Modernzir, check if there are necessary tests
for ( testName in tests) {
if ( !Modernizr.hasOwnProperty( testName ) ) {
// if test hasn't been run, use addTest to run it
Modernizr.addTest( testName, tests[ testName ] );
}
}
} else {
// or create new mini Modernizr that just has the 3 tests
Modernizr = window.Modernizr = {
_version : '1.6ish: miniModernizr for Isotope'
};
var classes = ' ';
var result;
// Run through tests
for ( testName in tests) {
result = tests[ testName ]();
Modernizr[ testName ] = result;
classes += ' ' + ( result ? '' : 'no-' ) + testName;
}
// Add the new classes to the <html> element.
$('html').addClass( classes );
}
// ========================= isoTransform ===============================
/**
* provides hooks for .css({ scale: value, translate: [x, y] })
* Progressively enhanced CSS transforms
* Uses hardware accelerated 3D transforms for Safari
* or falls back to 2D transforms.
*/
if ( Modernizr.csstransforms ) {
// i.e. transformFnNotations.scale(0.5) >> 'scale3d( 0.5, 0.5, 1)'
var transformFnNotations = Modernizr.csstransforms3d ?
{ // 3D transform functions
translate : function ( position ) {
return 'translate3d(' + position[0] + 'px, ' + position[1] + 'px, 0) ';
},
scale : function ( scale ) {
return 'scale3d(' + scale + ', ' + scale + ', 1) ';
}
} :
{ // 2D transform functions
translate : function ( position ) {
return 'translate(' + position[0] + 'px, ' + position[1] + 'px) ';
},
scale : function ( scale ) {
return 'scale(' + scale + ') ';
}
}
;
var setIsoTransform = function ( elem, name, value ) {
// unpack current transform data
var data = $.data( elem, 'isoTransform' ) || {},
newData = {},
fnName,
transformObj = {},
transformValue;
// i.e. newData.scale = 0.5
newData[ name ] = value;
// extend new value over current data
$.extend( data, newData );
for ( fnName in data ) {
transformValue = data[ fnName ];
transformObj[ fnName ] = transformFnNotations[ fnName ]( transformValue );
}
// get proper order
// ideally, we could loop through this give an array, but since we only have
// a couple transforms we're keeping track of, we'll do it like so
var translateFn = transformObj.translate || '',
scaleFn = transformObj.scale || '',
// sorting so translate always comes first
valueFns = translateFn + scaleFn;
// set data back in elem
$.data( elem, 'isoTransform', data );
// set name to vendor specific property
elem.style[ transformProp ] = valueFns;
};
// ==================== scale ===================
$.cssNumber.scale = true;
$.cssHooks.scale = {
set: function( elem, value ) {
// uncomment this bit if you want to properly parse strings
// if ( typeof value === 'string' ) {
// value = parseFloat( value );
// }
setIsoTransform( elem, 'scale', value );
},
get: function( elem, computed ) {
var transform = $.data( elem, 'isoTransform' );
return transform && transform.scale ? transform.scale : 1;
}
};
$.fx.step.scale = function( fx ) {
$.cssHooks.scale.set( fx.elem, fx.now+fx.unit );
};
// ==================== translate ===================
$.cssNumber.translate = true;
$.cssHooks.translate = {
set: function( elem, value ) {
// uncomment this bit if you want to properly parse strings
// if ( typeof value === 'string' ) {
// value = value.split(' ');
// }
//
// var i, val;
// for ( i = 0; i < 2; i++ ) {
// val = value[i];
// if ( typeof val === 'string' ) {
// val = parseInt( val );
// }
// }
setIsoTransform( elem, 'translate', value );
},
get: function( elem, computed ) {
var transform = $.data( elem, 'isoTransform' );
return transform && transform.translate ? transform.translate : [ 0, 0 ];
}
};
}
// ========================= get transition-end event ===============================
var transitionEndEvent, transitionDurProp;
if ( Modernizr.csstransitions ) {
transitionEndEvent = {
WebkitTransitionProperty: 'webkitTransitionEnd', // webkit
MozTransitionProperty: 'transitionend',
OTransitionProperty: 'oTransitionEnd otransitionend',
transitionProperty: 'transitionend'
}[ transitionProp ];
transitionDurProp = getStyleProperty('transitionDuration');
}
// ========================= smartresize ===============================
/*
* smartresize: debounced resize event for jQuery
*
* latest version and complete README available on Github:
* https://github.com/louisremi/jquery.smartresize.js
*
* Copyright 2011 @louis_remi
* Licensed under the MIT license.
*/
var $event = $.event,
resizeTimeout;
$event.special.smartresize = {
setup: function() {
$(this).bind( "resize", $event.special.smartresize.handler );
},
teardown: function() {
$(this).unbind( "resize", $event.special.smartresize.handler );
},
handler: function( event, execAsap ) {
// Save the context
var context = this,
args = arguments;
// set correct event type
event.type = "smartresize";
if ( resizeTimeout ) { clearTimeout( resizeTimeout ); }
resizeTimeout = setTimeout(function() {
jQuery.event.handle.apply( context, args );
}, execAsap === "execAsap"? 0 : 100 );
}
};
$.fn.smartresize = function( fn ) {
return fn ? this.bind( "smartresize", fn ) : this.trigger( "smartresize", ["execAsap"] );
};
// ========================= Isotope ===============================
// our "Widget" object constructor
$.Isotope = function( options, element, callback ){
this.element = $( element );
this._create( options );
this._init( callback );
};
// styles of container element we want to keep track of
var isoContainerStyles = [ 'width', 'height' ];
var $window = $(window);
$.Isotope.settings = {
resizable: true,
layoutMode : 'masonry',
containerClass : 'isotope',
itemClass : 'isotope-item',
hiddenClass : 'isotope-hidden',
hiddenStyle: { opacity: 0, scale: 0.001 },
visibleStyle: { opacity: 1, scale: 1 },
containerStyle: {
position: 'relative',
overflow: 'hidden'
},
animationEngine: 'best-available',
animationOptions: {
queue: false,
duration: 800
},
sortBy : 'original-order',
sortAscending : true,
resizesContainer : true,
transformsEnabled: true,
itemPositionDataEnabled: false
};
$.Isotope.prototype = {
// sets up widget
_create : function( options ) {
this.options = $.extend( {}, $.Isotope.settings, options );
this.styleQueue = [];
this.elemCount = 0;
// get original styles in case we re-apply them in .destroy()
var elemStyle = this.element[0].style;
this.originalStyle = {};
// keep track of container styles
var containerStyles = isoContainerStyles.slice(0);
for ( var prop in this.options.containerStyle ) {
containerStyles.push( prop );
}
for ( var i=0, len = containerStyles.length; i < len; i++ ) {
prop = containerStyles[i];
this.originalStyle[ prop ] = elemStyle[ prop ] || '';
}
// apply container style from options
this.element.css( this.options.containerStyle );
this._updateAnimationEngine();
this._updateUsingTransforms();
// sorting
var originalOrderSorter = {
'original-order' : function( $elem, instance ) {
instance.elemCount ++;
return instance.elemCount;
},
random : function() {
return Math.random();
}
};
this.options.getSortData = $.extend( this.options.getSortData, originalOrderSorter );
// need to get atoms
this.reloadItems();
// get top left position of where the bricks should be
this.offset = {
left: parseInt( ( this.element.css('padding-left') || 0 ), 10 ),
top: parseInt( ( this.element.css('padding-top') || 0 ), 10 )
};
// add isotope class first time around
var instance = this;
setTimeout( function() {
instance.element.addClass( instance.options.containerClass );
}, 0 );
// bind resize method
if ( this.options.resizable ) {
$window.bind( 'smartresize.isotope', function() {
instance.resize();
});
}
// dismiss all click events from hidden events
this.element.delegate( '.' + this.options.hiddenClass, 'click', function(){
return false;
});
},
_getAtoms : function( $elems ) {
var selector = this.options.itemSelector,
// filter & find
$atoms = selector ? $elems.filter( selector ).add( $elems.find( selector ) ) : $elems,
// base style for atoms
atomStyle = { position: 'absolute' };
if ( this.usingTransforms ) {
atomStyle.left = 0;
atomStyle.top = 0;
}
$atoms.css( atomStyle ).addClass( this.options.itemClass );
this.updateSortData( $atoms, true );
return $atoms;
},
// _init fires when your instance is first created
// (from the constructor above), and when you
// attempt to initialize the widget again (by the bridge)
// after it has already been initialized.
_init : function( callback ) {
this.$filteredAtoms = this._filter( this.$allAtoms );
this._sort();
this.reLayout( callback );
},
option : function( opts ){
// change options AFTER initialization:
// signature: $('#foo').bar({ cool:false });
if ( $.isPlainObject( opts ) ){
this.options = $.extend( true, this.options, opts );
// trigger _updateOptionName if it exists
var updateOptionFn;
for ( var optionName in opts ) {
updateOptionFn = '_update' + capitalize( optionName );
if ( this[ updateOptionFn ] ) {
this[ updateOptionFn ]();
}
}
}
},
// ====================== updaters ====================== //
// kind of like setters
_updateAnimationEngine : function() {
var animationEngine = this.options.animationEngine.toLowerCase().replace( /[ _\-]/g, '');
var isUsingJQueryAnimation;
// set applyStyleFnName
switch ( animationEngine ) {
case 'css' :
case 'none' :
isUsingJQueryAnimation = false;
break;
case 'jquery' :
isUsingJQueryAnimation = true;
break;
default : // best available
isUsingJQueryAnimation = !Modernizr.csstransitions;
}
this.isUsingJQueryAnimation = isUsingJQueryAnimation;
this._updateUsingTransforms();
},
_updateTransformsEnabled : function() {
this._updateUsingTransforms();
},
_updateUsingTransforms : function() {
var usingTransforms = this.usingTransforms = this.options.transformsEnabled &&
Modernizr.csstransforms && Modernizr.csstransitions && !this.isUsingJQueryAnimation;
// prevent scales when transforms are disabled
if ( !usingTransforms ) {
delete this.options.hiddenStyle.scale;
delete this.options.visibleStyle.scale;
}
this.getPositionStyles = usingTransforms ? this._translate : this._positionAbs;
},
// ====================== Filtering ======================
_filter : function( $atoms ) {
var filter = this.options.filter === '' ? '*' : this.options.filter;
if ( !filter ) {
return $atoms;
}
var hiddenClass = this.options.hiddenClass,
hiddenSelector = '.' + hiddenClass,
$hiddenAtoms = $atoms.filter( hiddenSelector ),
$atomsToShow = $hiddenAtoms;
if ( filter !== '*' ) {
$atomsToShow = $hiddenAtoms.filter( filter );
var $atomsToHide = $atoms.not( hiddenSelector ).not( filter ).addClass( hiddenClass );
this.styleQueue.push({ $el: $atomsToHide, style: this.options.hiddenStyle });
}
this.styleQueue.push({ $el: $atomsToShow, style: this.options.visibleStyle });
$atomsToShow.removeClass( hiddenClass );
return $atoms.filter( filter );
},
// ====================== Sorting ======================
updateSortData : function( $atoms, isIncrementingElemCount ) {
var instance = this,
getSortData = this.options.getSortData,
$this, sortData;
$atoms.each(function(){
$this = $(this);
sortData = {};
// get value for sort data based on fn( $elem ) passed in
for ( var key in getSortData ) {
if ( !isIncrementingElemCount && key === 'original-order' ) {
// keep original order original
sortData[ key ] = $.data( this, 'isotope-sort-data' )[ key ];
} else {
sortData[ key ] = getSortData[ key ]( $this, instance );
}
}
// apply sort data to element
$.data( this, 'isotope-sort-data', sortData );
});
},
// used on all the filtered atoms
_sort : function() {
var sortBy = this.options.sortBy,
getSorter = this._getSorter,
sortDir = this.options.sortAscending ? 1 : -1,
sortFn = function( alpha, beta ) {
var a = getSorter( alpha, sortBy ),
b = getSorter( beta, sortBy );
// fall back to original order if data matches
if ( a === b && sortBy !== 'original-order') {
a = getSorter( alpha, 'original-order' );
b = getSorter( beta, 'original-order' );
}
return ( ( a > b ) ? 1 : ( a < b ) ? -1 : 0 ) * sortDir;
};
this.$filteredAtoms.sort( sortFn );
},
_getSorter : function( elem, sortBy ) {
return $.data( elem, 'isotope-sort-data' )[ sortBy ];
},
// ====================== Layout Helpers ======================
_translate : function( x, y ) {
return { translate : [ x, y ] };
},
_positionAbs : function( x, y ) {
return { left: x, top: y };
},
_pushPosition : function( $elem, x, y ) {
x = Math.round( x + this.offset.left );
y = Math.round( y + this.offset.top );
var position = this.getPositionStyles( x, y );
this.styleQueue.push({ $el: $elem, style: position });
if ( this.options.itemPositionDataEnabled ) {
$elem.data('isotope-item-position', {x: x, y: y} );
}
},
// ====================== General Layout ======================
// used on collection of atoms (should be filtered, and sorted before )
// accepts atoms-to-be-laid-out to start with
layout : function( $elems, callback ) {
var layoutMode = this.options.layoutMode;
// layout logic
this[ '_' + layoutMode + 'Layout' ]( $elems );
// set the size of the container
if ( this.options.resizesContainer ) {
var containerStyle = this[ '_' + layoutMode + 'GetContainerSize' ]();
this.styleQueue.push({ $el: this.element, style: containerStyle });
}
this._processStyleQueue( $elems, callback );
this.isLaidOut = true;
},
_processStyleQueue : function( $elems, callback ) {
// are we animating the layout arrangement?
// use plugin-ish syntax for css or animate
var styleFn = !this.isLaidOut ? 'css' : (
this.isUsingJQueryAnimation ? 'animate' : 'css'
),
animOpts = this.options.animationOptions,
onLayout = this.options.onLayout,
objStyleFn, processor,
triggerCallbackNow, callbackFn;
// default styleQueue processor, may be overwritten down below
processor = function( i, obj ) {
obj.$el[ styleFn ]( obj.style, animOpts );
};
if ( this._isInserting && this.isUsingJQueryAnimation ) {
// if using styleQueue to insert items
processor = function( i, obj ) {
// only animate if it not being inserted
objStyleFn = obj.$el.hasClass('no-transition') ? 'css' : styleFn;
obj.$el[ objStyleFn ]( obj.style, animOpts );
};
} else if ( callback || onLayout || animOpts.complete ) {
// has callback
var isCallbackTriggered = false,
// array of possible callbacks to trigger
callbacks = [ callback, onLayout, animOpts.complete ],
instance = this;
triggerCallbackNow = true;
// trigger callback only once
callbackFn = function() {
if ( isCallbackTriggered ) {
return;
}
var hollaback;
for (var i=0, len = callbacks.length; i < len; i++) {
hollaback = callbacks[i];
if ( typeof hollaback === 'function' ) {
hollaback.call( instance.element, $elems, instance );
}
}
isCallbackTriggered = true;
};
if ( this.isUsingJQueryAnimation && styleFn === 'animate' ) {
// add callback to animation options
animOpts.complete = callbackFn;
triggerCallbackNow = false;
} else if ( Modernizr.csstransitions ) {
// detect if first item has transition
var i = 0,
firstItem = this.styleQueue[0],
testElem = firstItem && firstItem.$el,
styleObj;
// get first non-empty jQ object
while ( !testElem || !testElem.length ) {
styleObj = this.styleQueue[ i++ ];
// HACK: sometimes styleQueue[i] is undefined
if ( !styleObj ) {
return;
}
testElem = styleObj.$el;
}
// get transition duration of the first element in that object
// yeah, this is inexact
var duration = parseFloat( getComputedStyle( testElem[0] )[ transitionDurProp ] );
if ( duration > 0 ) {
processor = function( i, obj ) {
obj.$el[ styleFn ]( obj.style, animOpts )
// trigger callback at transition end
.one( transitionEndEvent, callbackFn );
};
triggerCallbackNow = false;
}
}
}
// process styleQueue
$.each( this.styleQueue, processor );
if ( triggerCallbackNow ) {
callbackFn();
}
// clear out queue for next time
this.styleQueue = [];
},
resize : function() {
if ( this[ '_' + this.options.layoutMode + 'ResizeChanged' ]() ) {
this.reLayout();
}
},
reLayout : function( callback ) {
this[ '_' + this.options.layoutMode + 'Reset' ]();
this.layout( this.$filteredAtoms, callback );
},
// ====================== Convenience methods ======================
// ====================== Adding items ======================
// adds a jQuery object of items to a isotope container
addItems : function( $content, callback ) {
var $newAtoms = this._getAtoms( $content );
// add new atoms to atoms pools
this.$allAtoms = this.$allAtoms.add( $newAtoms );
if ( callback ) {
callback( $newAtoms );
}
},
// convienence method for adding elements properly to any layout
// positions items, hides them, then animates them back in <--- very sezzy
insert : function( $content, callback ) {
// position items
this.element.append( $content );
var instance = this;
this.addItems( $content, function( $newAtoms ) {
var $newFilteredAtoms = instance._filter( $newAtoms );
instance._addHideAppended( $newFilteredAtoms );
instance._sort();
instance.reLayout();
instance._revealAppended( $newFilteredAtoms, callback );
});
},
// convienence method for working with Infinite Scroll
appended : function( $content, callback ) {
var instance = this;
this.addItems( $content, function( $newAtoms ) {
instance._addHideAppended( $newAtoms );
instance.layout( $newAtoms );
instance._revealAppended( $newAtoms, callback );
});
},
// adds new atoms, then hides them before positioning
_addHideAppended : function( $newAtoms ) {
this.$filteredAtoms = this.$filteredAtoms.add( $newAtoms );
$newAtoms.addClass('no-transition');
this._isInserting = true;
// apply hidden styles
this.styleQueue.push({ $el: $newAtoms, style: this.options.hiddenStyle });
},
// sets visible style on new atoms
_revealAppended : function( $newAtoms, callback ) {
var instance = this;
// apply visible style after a sec
setTimeout( function() {
// enable animation
$newAtoms.removeClass('no-transition');
// reveal newly inserted filtered elements
instance.styleQueue.push({ $el: $newAtoms, style: instance.options.visibleStyle });
instance._isInserting = false;
instance._processStyleQueue( $newAtoms, callback );
}, 10 );
},
// gathers all atoms
reloadItems : function() {
this.$allAtoms = this._getAtoms( this.element.children() );
},
// removes elements from Isotope widget
remove: function( $content, callback ) {
// remove elements immediately from Isotope instance
this.$allAtoms = this.$allAtoms.not( $content );
this.$filteredAtoms = this.$filteredAtoms.not( $content );
// remove() as a callback, for after transition / animation
var instance = this;
var removeContent = function() {
$content.remove();
if ( callback ) {
callback.call( instance.element );
}
};
if ( $content.filter( ':not(.' + this.options.hiddenClass + ')' ).length ) {
// if any non-hidden content needs to be removed
this.styleQueue.push({ $el: $content, style: this.options.hiddenStyle });
this._sort();
this.reLayout( removeContent );
} else {
// remove it now
removeContent();
}
},
shuffle : function( callback ) {
this.updateSortData( this.$allAtoms );
this.options.sortBy = 'random';
this._sort();
this.reLayout( callback );
},
// destroys widget, returns elements and container back (close) to original style
destroy : function() {
var usingTransforms = this.usingTransforms;
var options = this.options;
this.$allAtoms
.removeClass( options.hiddenClass + ' ' + options.itemClass )
.each(function(){
var style = this.style;
style.position = '';
style.top = '';
style.left = '';
style.opacity = '';
if ( usingTransforms ) {
style[ transformProp ] = '';
}
});
// re-apply saved container styles
var elemStyle = this.element[0].style;
for ( var prop in this.originalStyle ) {
elemStyle[ prop ] = this.originalStyle[ prop ];
}
this.element
.unbind('.isotope')
.undelegate( '.' + options.hiddenClass, 'click' )
.removeClass( options.containerClass )
.removeData('isotope');
$window.unbind('.isotope');
},
// ====================== LAYOUTS ======================
// calculates number of rows or columns
// requires columnWidth or rowHeight to be set on namespaced object
// i.e. this.masonry.columnWidth = 200
_getSegments : function( isRows ) {
var namespace = this.options.layoutMode,
measure = isRows ? 'rowHeight' : 'columnWidth',
size = isRows ? 'height' : 'width',
segmentsName = isRows ? 'rows' : 'cols',
containerSize = this.element[ size ](),
segments,
// i.e. options.masonry && options.masonry.columnWidth
segmentSize = this.options[ namespace ] && this.options[ namespace ][ measure ] ||
// or use the size of the first item, i.e. outerWidth
this.$filteredAtoms[ 'outer' + capitalize(size) ](true) ||
// if there's no items, use size of container
containerSize;
segments = Math.floor( containerSize / segmentSize );
segments = Math.max( segments, 1 );
// i.e. this.masonry.cols = ....
this[ namespace ][ segmentsName ] = segments;
// i.e. this.masonry.columnWidth = ...
this[ namespace ][ measure ] = segmentSize;
},
_checkIfSegmentsChanged : function( isRows ) {
var namespace = this.options.layoutMode,
segmentsName = isRows ? 'rows' : 'cols',
prevSegments = this[ namespace ][ segmentsName ];
// update cols/rows
this._getSegments( isRows );
// return if updated cols/rows is not equal to previous
return ( this[ namespace ][ segmentsName ] !== prevSegments );
},
// ====================== Masonry ======================
_masonryReset : function() {
// layout-specific props
this.masonry = {};
// FIXME shouldn't have to call this again
this._getSegments();
var i = this.masonry.cols;
this.masonry.colYs = [];
while (i--) {
this.masonry.colYs.push( 0 );
}
},
_masonryLayout : function( $elems ) {
var instance = this,
props = instance.masonry;
$elems.each(function(){
var $this = $(this),
//how many columns does this brick span
colSpan = Math.ceil( $this.outerWidth(true) / props.columnWidth );
colSpan = Math.min( colSpan, props.cols );
if ( colSpan === 1 ) {
// if brick spans only one column, just like singleMode
instance._masonryPlaceBrick( $this, props.colYs );
} else {
// brick spans more than one column
// how many different places could this brick fit horizontally
var groupCount = props.cols + 1 - colSpan,
groupY = [],
groupColY,
i;
// for each group potential horizontal position
for ( i=0; i < groupCount; i++ ) {
// make an array of colY values for that one group
groupColY = props.colYs.slice( i, i+colSpan );
// and get the max value of the array
groupY[i] = Math.max.apply( Math, groupColY );
}
instance._masonryPlaceBrick( $this, groupY );
}
});
},
// worker method that places brick in the columnSet
// with the the minY
_masonryPlaceBrick : function( $brick, setY ) {
// get the minimum Y value from the columns
var minimumY = Math.min.apply( Math, setY ),
shortCol = 0;
// Find index of short column, the first from the left
for (var i=0, len = setY.length; i < len; i++) {
if ( setY[i] === minimumY ) {
shortCol = i;
break;
}
}
// position the brick
var x = this.masonry.columnWidth * shortCol,
y = minimumY;
this._pushPosition( $brick, x, y );
// apply setHeight to necessary columns
var setHeight = minimumY + $brick.outerHeight(true),
setSpan = this.masonry.cols + 1 - len;
for ( i=0; i < setSpan; i++ ) {
this.masonry.colYs[ shortCol + i ] = setHeight;
}
},
_masonryGetContainerSize : function() {
var containerHeight = Math.max.apply( Math, this.masonry.colYs );
return { height: containerHeight };
},
_masonryResizeChanged : function() {
return this._checkIfSegmentsChanged();
},
// ====================== fitRows ======================
_fitRowsReset : function() {
this.fitRows = {
x : 0,
y : 0,
height : 0
};
},
_fitRowsLayout : function( $elems ) {
var instance = this,
containerWidth = this.element.width(),
props = this.fitRows;
$elems.each( function() {
var $this = $(this),
atomW = $this.outerWidth(true),
atomH = $this.outerHeight(true);
if ( props.x !== 0 && atomW + props.x > containerWidth ) {
// if this element cannot fit in the current row
props.x = 0;
props.y = props.height;
}
// position the atom
instance._pushPosition( $this, props.x, props.y );
props.height = Math.max( props.y + atomH, props.height );
props.x += atomW;
});
},
_fitRowsGetContainerSize : function () {
return { height : this.fitRows.height };
},
_fitRowsResizeChanged : function() {
return true;
},
// ====================== cellsByRow ======================
_cellsByRowReset : function() {
this.cellsByRow = {
index : 0
};
// get this.cellsByRow.columnWidth
this._getSegments();
// get this.cellsByRow.rowHeight
this._getSegments(true);
},
_cellsByRowLayout : function( $elems ) {
var instance = this,
props = this.cellsByRow;
$elems.each( function(){
var $this = $(this),
col = props.index % props.cols,
row = Math.floor( props.index / props.cols ),
x = ( col + 0.5 ) * props.columnWidth - $this.outerWidth(true) / 2,
y = ( row + 0.5 ) * props.rowHeight - $this.outerHeight(true) / 2;
instance._pushPosition( $this, x, y );
props.index ++;
});
},
_cellsByRowGetContainerSize : function() {
return { height : Math.ceil( this.$filteredAtoms.length / this.cellsByRow.cols ) * this.cellsByRow.rowHeight + this.offset.top };
},
_cellsByRowResizeChanged : function() {
return this._checkIfSegmentsChanged();
},
// ====================== straightDown ======================
_straightDownReset : function() {
this.straightDown = {
y : 0
};
},
_straightDownLayout : function( $elems ) {
var instance = this;
$elems.each( function( i ){
var $this = $(this);
instance._pushPosition( $this, 0, instance.straightDown.y );
instance.straightDown.y += $this.outerHeight(true);
});
},
_straightDownGetContainerSize : function() {
return { height : this.straightDown.y };
},
_straightDownResizeChanged : function() {
return true;
},
// ====================== masonryHorizontal ======================
_masonryHorizontalReset : function() {
// layout-specific props
this.masonryHorizontal = {};
// FIXME shouldn't have to call this again
this._getSegments( true );
var i = this.masonryHorizontal.rows;
this.masonryHorizontal.rowXs = [];
while (i--) {
this.masonryHorizontal.rowXs.push( 0 );
}
},
_masonryHorizontalLayout : function( $elems ) {
var instance = this,
props = instance.masonryHorizontal;
$elems.each(function(){
var $this = $(this),
//how many rows does this brick span
rowSpan = Math.ceil( $this.outerHeight(true) / props.rowHeight );
rowSpan = Math.min( rowSpan, props.rows );
if ( rowSpan === 1 ) {
// if brick spans only one column, just like singleMode
instance._masonryHorizontalPlaceBrick( $this, props.rowXs );
} else {
// brick spans more than one row
// how many different places could this brick fit horizontally
var groupCount = props.rows + 1 - rowSpan,
groupX = [],
groupRowX, i;
// for each group potential horizontal position
for ( i=0; i < groupCount; i++ ) {
// make an array of colY values for that one group
groupRowX = props.rowXs.slice( i, i+rowSpan );
// and get the max value of the array
groupX[i] = Math.max.apply( Math, groupRowX );
}
instance._masonryHorizontalPlaceBrick( $this, groupX );
}
});
},
_masonryHorizontalPlaceBrick : function( $brick, setX ) {
// get the minimum Y value from the columns
var minimumX = Math.min.apply( Math, setX ),
smallRow = 0;
// Find index of smallest row, the first from the top
for (var i=0, len = setX.length; i < len; i++) {
if ( setX[i] === minimumX ) {
smallRow = i;
break;
}
}
// position the brick
var x = minimumX,
y = this.masonryHorizontal.rowHeight * smallRow;
this._pushPosition( $brick, x, y );
// apply setHeight to necessary columns
var setWidth = minimumX + $brick.outerWidth(true),
setSpan = this.masonryHorizontal.rows + 1 - len;
for ( i=0; i < setSpan; i++ ) {
this.masonryHorizontal.rowXs[ smallRow + i ] = setWidth;
}
},
_masonryHorizontalGetContainerSize : function() {
var containerWidth = Math.max.apply( Math, this.masonryHorizontal.rowXs );
return { width: containerWidth };
},
_masonryHorizontalResizeChanged : function() {
return this._checkIfSegmentsChanged(true);
},
// ====================== fitColumns ======================
_fitColumnsReset : function() {
this.fitColumns = {
x : 0,
y : 0,
width : 0
};
},
_fitColumnsLayout : function( $elems ) {
var instance = this,
containerHeight = this.element.height(),
props = this.fitColumns;
$elems.each( function() {
var $this = $(this),
atomW = $this.outerWidth(true),
atomH = $this.outerHeight(true);
if ( props.y !== 0 && atomH + props.y > containerHeight ) {
// if this element cannot fit in the current column
props.x = props.width;
props.y = 0;
}
// position the atom
instance._pushPosition( $this, props.x, props.y );
props.width = Math.max( props.x + atomW, props.width );
props.y += atomH;
});
},
_fitColumnsGetContainerSize : function () {
return { width : this.fitColumns.width };
},
_fitColumnsResizeChanged : function() {
return true;
},
// ====================== cellsByColumn ======================
_cellsByColumnReset : function() {
this.cellsByColumn = {
index : 0
};
// get this.cellsByColumn.columnWidth
this._getSegments();
// get this.cellsByColumn.rowHeight
this._getSegments(true);
},
_cellsByColumnLayout : function( $elems ) {
var instance = this,
props = this.cellsByColumn;
$elems.each( function(){
var $this = $(this),
col = Math.floor( props.index / props.rows ),
row = props.index % props.rows,
x = ( col + 0.5 ) * props.columnWidth - $this.outerWidth(true) / 2,
y = ( row + 0.5 ) * props.rowHeight - $this.outerHeight(true) / 2;
instance._pushPosition( $this, x, y );
props.index ++;
});
},
_cellsByColumnGetContainerSize : function() {
return { width : Math.ceil( this.$filteredAtoms.length / this.cellsByColumn.rows ) * this.cellsByColumn.columnWidth };
},
_cellsByColumnResizeChanged : function() {
return this._checkIfSegmentsChanged(true);
},
// ====================== straightAcross ======================
_straightAcrossReset : function() {
this.straightAcross = {
x : 0
};
},
_straightAcrossLayout : function( $elems ) {
var instance = this;
$elems.each( function( i ){
var $this = $(this);
instance._pushPosition( $this, instance.straightAcross.x, 0 );
instance.straightAcross.x += $this.outerWidth(true);
});
},
_straightAcrossGetContainerSize : function() {
return { width : this.straightAcross.x };
},
_straightAcrossResizeChanged : function() {
return true;
}
};
// ======================= imagesLoaded Plugin ===============================
/*!
* jQuery imagesLoaded plugin v1.1.0
* http://github.com/desandro/imagesloaded
*
* MIT License. by Paul Irish et al.
*/
// $('#my-container').imagesLoaded(myFunction)
// or
// $('img').imagesLoaded(myFunction)
// execute a callback when all images have loaded.
// needed because .load() doesn't work on cached images
// callback function gets image collection as argument
// `this` is the container
$.fn.imagesLoaded = function( callback ) {
var $this = this,
$images = $this.find('img').add( $this.filter('img') ),
len = $images.length,
blank = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==',
loaded = [];
function triggerCallback() {
callback.call( $this, $images );
}
function imgLoaded( event ) {
var img = event.target;
if ( img.src !== blank && $.inArray( img, loaded ) === -1 ){
loaded.push( img );
if ( --len <= 0 ){
setTimeout( triggerCallback );
$images.unbind( '.imagesLoaded', imgLoaded );
}
}
}
// if no images, trigger immediately
if ( !len ) {
triggerCallback();
}
$images.bind( 'load.imagesLoaded error.imagesLoaded', imgLoaded ).each( function() {
// cached images don't fire load sometimes, so we reset src.
var src = this.src;
// webkit hack from http://groups.google.com/group/jquery-dev/browse_thread/thread/eee6ab7b2da50e1f
// data uri bypasses webkit log warning (thx doug jones)
this.src = blank;
this.src = src;
});
return $this;
};
// helper function for logging errors
// $.error breaks jQuery chaining
var logError = function( message ) {
if ( window.console ) {
window.console.error( message );
}
};
// ======================= Plugin bridge ===============================
// leverages data method to either create or return $.Isotope constructor
// A bit from jQuery UI
// https://github.com/jquery/jquery-ui/blob/master/ui/jquery.ui.widget.js
// A bit from jcarousel
// https://github.com/jsor/jcarousel/blob/master/lib/jquery.jcarousel.js
$.fn.isotope = function( options, callback ) {
if ( typeof options === 'string' ) {
// call method
var args = Array.prototype.slice.call( arguments, 1 );
this.each(function(){
var instance = $.data( this, 'isotope' );
if ( !instance ) {
logError( "cannot call methods on isotope prior to initialization; " +
"attempted to call method '" + options + "'" );
return;
}
if ( !$.isFunction( instance[options] ) || options.charAt(0) === "_" ) {
logError( "no such method '" + options + "' for isotope instance" );
return;
}
// apply method
instance[ options ].apply( instance, args );
});
} else {
this.each(function() {
var instance = $.data( this, 'isotope' );
if ( instance ) {
// apply options & init
instance.option( options );
instance._init( callback );
} else {
// initialize new instance
$.data( this, 'isotope', new $.Isotope( options, this, callback ) );
}
});
}
// return jQuery object
// so plugin methods do not have to
return this;
};
})( window, jQuery );
(function($, window, document, undefined) {
$.fn.quicksearch = function (target, opt) {
var timeout, cache, rowcache, jq_results, val = '', e = this, options = $.extend({
delay: 100,
selector: null,
stripeRows: null,
loader: null,
noResults: '',
matchedResultsCount: 0,
bind: 'keyup',
onBefore: function () {
return;
},
onAfter: function () {
return;
},
show: function () {
this.style.opacity = "1";
},
hide: function () {
this.style.opacity = "0";
},
prepareQuery: function (val) {
return val.toLowerCase().split(' ');
},
testQuery: function (query, txt, _row) {
for (var i = 0; i < query.length; i += 1) {
if (txt.indexOf(query[i]) === -1) {
return false;
}
}
return true;
}
}, opt);
this.go = function () {
var i = 0,
numMatchedRows = 0,
noresults = true,
query = options.prepareQuery(val),
val_empty = (val.replace(' ', '').length === 0);
for (var i = 0, len = rowcache.length; i < len; i++) {
if (val_empty || options.testQuery(query, cache[i], rowcache[i])) {
options.show.apply(rowcache[i]);
noresults = false;
numMatchedRows++;
} else {
options.hide.apply(rowcache[i]);
}
}
if (noresults) {
this.results(false);
} else {
this.results(true);
this.stripe();
}
this.matchedResultsCount = numMatchedRows;
this.loader(false);
options.onAfter();
return this;
};
/*
* External API so that users can perform search programatically.
* */
this.search = function (submittedVal) {
val = submittedVal;
e.trigger();
};
/*
* External API to get the number of matched results as seen in
* https://github.com/ruiz107/quicksearch/commit/f78dc440b42d95ce9caed1d087174dd4359982d6
* */
this.currentMatchedResults = function() {
return this.matchedResultsCount;
};
this.stripe = function () {
if (typeof options.stripeRows === "object" && options.stripeRows !== null)
{
var joined = options.stripeRows.join(' ');
var stripeRows_length = options.stripeRows.length;
jq_results.not(':hidden').each(function (i) {
$(this).removeClass(joined).addClass(options.stripeRows[i % stripeRows_length]);
});
}
return this;
};
this.strip_html = function (input) {
var output = input.replace(new RegExp('<[^<]+\>', 'g'), "");
output = $.trim(output.toLowerCase());
return output;
};
this.results = function (bool) {
if (typeof options.noResults === "string" && options.noResults !== "") {
if (bool) {
$(options.noResults).hide();
} else {
$(options.noResults).show();
}
}
return this;
};
this.loader = function (bool) {
if (typeof options.loader === "string" && options.loader !== "") {
(bool) ? $(options.loader).show() : $(options.loader).hide();
}
return this;
};
this.cache = function () {
jq_results = $(target);
if (typeof options.noResults === "string" && options.noResults !== "") {
jq_results = jq_results.not(options.noResults);
}
var t = (typeof options.selector === "string") ? jq_results.find(options.selector) : $(target).not(options.noResults);
cache = t.map(function () {
return e.strip_html(this.innerHTML);
});
rowcache = jq_results.map(function () {
return this;
});
/*
* Modified fix for sync-ing "val".
* Original fix https://github.com/michaellwest/quicksearch/commit/4ace4008d079298a01f97f885ba8fa956a9703d1
* */
val = val || this.val() || "";
return this.go();
};
this.trigger = function () {
this.loader(true);
options.onBefore();
window.clearTimeout(timeout);
timeout = window.setTimeout(function () {
e.go();
}, options.delay);
return this;
};
this.cache();
this.results(true);
this.stripe();
this.loader(false);
return this.each(function () {
/*
* Changed from .bind to .on.
* */
$(this).bind(options.bind, function () {
val = $(this).val();
e.trigger();
});
});
};
}(jQuery, this, document));
//***********FIELDS OF STUDY SCRIPTS***********
var $j = jQuery.noConflict();
$j(function() {
//set isotope variables
var $container = $j('#fields_container'),
filters = {};
$container.isotope({
itemSelector: '.box',
layoutMode : 'fitRows'
});
// filter buttons
$j('.filter .button a').click(function(){
var $this = $j(this);
// don't proceed if already selected
if ( $this.hasClass('selected') ) {
return;
}
var $optionSet = $this.parents('.option-set');
// change selected class
$optionSet.find('.selected').removeClass('selected');
$this.addClass('selected');
// store filter value in object
// i.e. filters.color = 'red'
var group = $optionSet.attr('data-filter-group');
filters[ group ] = $this.attr('data-filter');
// convert object into array
var isoFilters = [];
for ( var prop in filters ) {
isoFilters.push( filters[ prop ] )
}
var selector = isoFilters.join('');
$container.isotope({ filter: selector });
return false;
});
//Setup quicksearch
$j('#id_search').quicksearch('div.mobile-field', {
delay: 100,
bind: 'onchange keyup',
noResults: '#noresults',
'show': function() {
$j(this).addClass('quicksearch-match');
},
'hide': function() {
$j(this).removeClass('quicksearch-match');
}
}).keyup(function(){ //Add function to match quicksearch to isotopefilter
setTimeout( function() {
$container.isotope({ filter: '.quicksearch-match' }).isotope();
}, 100 );
});
});
|
/**
* @author Joe Adams
*/
goog.provide('CloseContact.Systems.ActorSystem');
goog.require('CrunchJS.System');
goog.require('CrunchJS.Components.RenderShape')
/**
* @constructor
* @class
*/
CloseContact.Systems.ActorSystem = function() {
goog.base(this);
};
goog.inherits(CloseContact.Systems.ActorSystem, CrunchJS.System);
CloseContact.Systems.ActorSystem.prototype.name = 'ActorSystem';
CloseContact.Systems.ActorSystem.prototype.activate = function() {
this.setEntityComposition(this.getScene().createEntityComposition().all('Transform', 'Actor'));
};
CloseContact.Systems.ActorSystem.prototype.processEntity = function(frame, entityId) {
var actor = this.getScene().getComponent(entityId, 'Actor'),
trans = this.getScene().getComponent(entityId, 'Transform'),
renderShape = this.getScene().getComponent(entityId, 'RenderShape');
if(!renderShape){
renderShape = new CrunchJS.Components.RenderShape({
type: 'rectangle',
color: actor.team == 0 ? '0xFF0000' : '0x0000FF',
size: {
x: 10,
y: 1.5
},
fill : true,
offset: {
x: 0,
y: -6
}
});
this.getScene().addComponent(entityId, renderShape);
}
renderShape.setSize(10*actor.getHealth()/actor.getMaxHealth(), renderShape.getSize().y);
}; |
/*
Copyright © 2018 Andrew Powell
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of this Source Code Form.
*/
const test = require('ava');
const { nodeToString, parse } = require('../lib');
const { options, snapshot, throws } = require('./fixtures/interpolation');
for (const fixture of snapshot) {
test(fixture, (t) => {
const root = parse(fixture, options);
const nodes = root.nodes.map((node) => {
delete node.parent; // eslint-disable-line no-param-reassign
return node;
});
const string = nodeToString(root);
t.is(string, fixture);
t.is(fixture, root.toString());
t.snapshot(root.first.toString());
t.snapshot(string);
t.snapshot(nodes);
});
}
for (const fixture of throws) {
test(fixture, (t) => {
t.throws(() => parse(fixture));
});
}
|
import Ember from 'ember';
import Resolver from 'ember/resolver';
export default Resolver.extend({
customPattern: function(parsedName) {
var name = parsedName.fullNameWithoutType;
var segs = name.split('/');
var postfix = '';
var type = this.pluralize(parsedName.type);
if (parsedName.type === 'template') {
segs.splice(0,1);
type = 'components';
postfix = '/template';
}
if (segs[0] === 'shared' || segs.length === 1) {
if (parsedName.type === 'component') {
postfix = '/component';
}
segs.splice(0,1);
var path = this.namespace.modulePrefix + '/shared/' + type + '/' + segs.join('/') + postfix;
return path;
}
},
moduleNameLookupPatterns: Ember.computed(function(){
var defaults = this._super();
return defaults.concat( this.customPattern );
})
}); |
import isEmpty from 'lodash/isEmpty';
import clone from 'lodash/clone';
import uniqueId from 'lodash/uniqueId';
import isFunction from 'lodash/isFunction';
export default class FormModelPrototype {
constructor(defaultModel, dispatch) {
this._defaultModel = defaultModel;
this._dispatch = dispatch;
this._formData = this._getDefaultModel();
this._extendWithNameAndKeyRecursive(this._formData);
this._invalidFields = [];
}
getInvalidFields() {
return this._invalidFields;
}
getData() {
return this._formData;
}
setData(values) {
this._formData = this._mergeRecursive(this._getDefaultModel(), values);
this._extendWithNameAndKeyRecursive(this._formData);
}
_addInvalidField(field) {
this._invalidFields.push(field);
}
_resetInvalidFields() {
this._invalidFields = [];
}
_getDefaultModel() {
if (isFunction(this._defaultModel)) {
return this._defaultModel();
}
return this._defaultModel;
}
_extendWithNameAndKeyRecursive(node) {
let { name = '' } = node;
if (node.hasOwnProperty('fields')) {
name = name ? `${name}.fields` : 'fields';
for (let key in node.fields) {
let propertyNode = node.fields[key];
propertyNode.name = `${name}.${key}`;
propertyNode.handleChange = (value, needValidate) => {
this.set(value, propertyNode.name, needValidate);
};
this._extendWithNameAndKeyRecursive(propertyNode);
}
} else if (node.hasOwnProperty('items')) {
const originName = node.name || '';
node.handleAdd = value => {
this.addItem(originName, node.defaultItem(value));
};
name = name ? `${name}.items` : 'items';
for (let key in node.items) {
let itemNode = node.items[key];
itemNode.handleRemove = this.removeItem.bind(this, originName, key);
itemNode.name = `${name}.${key}`;
if (!itemNode.key) {
itemNode.key = uniqueId('form_array_item_key_');
}
this._extendWithNameAndKeyRecursive(itemNode);
}
}
}
_mergeRecursive(node, valueNode) {
if (node.hasOwnProperty('fields')) {
if (valueNode.fields) {
for (let key in node.fields) {
this._mergeRecursive(node.fields[key], valueNode.fields[key] || []);
}
}
} else if (node.hasOwnProperty('items')) {
if (valueNode.items) {
var count = valueNode.items.length - node.items.length;
for (let i = 0; i < count; i++) {
node.items.push(node.defaultItem());
}
for (let key in node.items) {
this._mergeRecursive(node.items[key], valueNode.items[key] || []);
}
}
} else {
return { ...node, ...valueNode };
}
node = clone(node);
return node;
}
removeItem(name, index) {
console.log('remove', name + ".items[" + index + "]");
this._formData = {...this._formData};
const field = this._updateRecursive(this._formData, name.split('.'));
const { items } = field;
items.splice(index, 1);
field.items = clone(items);
this._extendWithNameAndKeyRecursive(field);
this._unsetError(field);
if (this._dispatch) {
this._dispatch();
}
}
addItem(name, item) {
console.log('add', name, JSON.stringify(item));
this._formData = {...this._formData};
const field = this._updateRecursive(this._formData, name.split('.'));
const { items } = field;
items.push(item);
field.items = clone(items);
this._extendWithNameAndKeyRecursive(field);
this._unsetError(item);
if (this._dispatch) {
this._dispatch();
}
}
set(value, name, needValidate) {
console.log('set', name, JSON.stringify(value));
this._formData = {...this._formData};
let field = this._updateRecursive(this._formData, name.split('.'));
field.value = value;
if (field.error) {
this._validateRecursive(field, false);
} else if (needValidate) {
this._validateRecursive(this._formData, false);
}
if (this._dispatch) {
this._dispatch();
}
}
validate = () => {
this._resetInvalidFields();
this._formData = {...this._formData};
return this._validateRecursive(this._formData, true);
}
_updateRecursive(node, [ currentName, ...tailNames ]) {
const newNode = node[currentName] = clone(node[currentName]);
if (!tailNames.length) {
return newNode;
}
return this._updateRecursive(newNode, tailNames);
}
_validateRecursive(node, needInvalidFields) {
var isValid = this._validateField(node);
if (!isValid && needInvalidFields) {
this._addInvalidField(node);
}
if (node.hasOwnProperty('fields')) {
for (let key in node.fields) {
isValid = this._validateRecursive(node.fields[key], needInvalidFields) && isValid;
}
} else if (node.hasOwnProperty('items')) {
for (let key in node.items) {
isValid = this._validateRecursive(node.items[key], needInvalidFields) && isValid;
}
}
return isValid;
}
_validateField(field) {
// если нет правила валидации, то все ок
if (!field.validation) {
this._unsetError(field);
return true;
}
// проверяем необязательное поле оно не заполнено, то все ок
if (!field.required) {
if (!field.value || isEmpty(field.value)) {
this._unsetError(field);
return true;
}
}
// иначе валидируем
var isFieldValid = field.validation(field, this._formData);
if (isFieldValid) {
this._unsetError(field);
} else {
this._setError(field);
}
return isFieldValid;
}
_setError(field) {
field.error = true;
this._updateRecursive(this._formData, field.name.split('.'));
}
_unsetError(field) {
field.error = false;
}
}
|
import React from 'react';
import PageContainer from '../components/PageContainer';
import { render } from 'react-dom'
import {
AboutUs
} from '../components/FontComponents'
import {
Grid,
Col,
Form,
Input,
Thumbnail,
Image,
Icon,
Button,
Panel,
Modal,
ModalTrigger,
} from 'amazeui-react';
import auth from '../components/auth'
import { browserHistory, Router, Route, Link, withRouter } from 'react-router'
var path = "i/companyLogo.png";
var iconUser = <Icon icon="user" />;
var iconPwd = <Icon icon="lock" />;
var FindPassword = React.createClass({
render() {
return (
<Grid>
<Col sm={4}></Col>
<Col sm={4}>
<p><span><a href="#"> 找回密码</a></span></p>
</Col>
</Grid>
);
}
});
const role_index = {
'5':'user_manage',
'4':'index_home',
'3':'index_home',
'2':'order',
'1':'index_home',
'0':'index_home',
}
const Login = withRouter(
React.createClass({
getInitialState() {
return {
error: false
}
},
handleSubmit:function(e){
e.preventDefault();
const email = this.refs.email.value
const pass = this.refs.pass.value
const role = '1'
if(!email||!pass){
alert("用户名或密码不可为空");
}else{
auth.logout()
auth.user_login(email, pass, (loggedIn) => {
if (!loggedIn){
console.log(email+pass)
return this.setState({ error: true })
}
const { location } = this.props
if (location.state && location.state.nextPathname) {
this.props.router.replace(location.state.nextPathname)
} else {
this.props.router.replace(role_index[auth.getRole()])
}
})
}
},
render() {
return (
<div>
<div id="base" class="">
<link href="i/resources/css/axure_rp_page.css" type="text/css" rel="stylesheet"/>
<link href="i/data/styles.css" type="text/css" rel="stylesheet"/>
<link href="i/css/user_login_page/styles.css" type="text/css" rel="stylesheet"/>
<form onSubmit={this.handleSubmit}>
<div id="u0" class="ax_shape">
<img id="u0_img" class="img " src="i/images/user_login_page/u0.png"/>
<div id="u1" class="text">
<p><span></span></p>
</div>
</div>
<div id="u2" class="ax_h1">
<img id="u2_img" class="img " src="i/resources/images/transparent.gif"/>
<div id="u3" class="text">
<p><span>欢迎登录</span></p>
</div>
</div>
<div id="u6" class="ax_shape">
<img id="u6_img" class="img " src="i/images/user_login_page/u6.png"/>
<div id="u7" class="text">
<p><span></span></p>
</div>
</div>
<div id="u8" class="ax_paragraph">
<img id="u8_img" class="img " src="i/resources/images/transparent.gif"/>
<Link to = '/register_user'>
<div id="u9" class="text">
<p><span>立即注册</span></p>
</div>
</Link>
</div>
<div id="u10" class="ax_text_field">
<input ref="email" id="u10_input" type="text"/>
</div>
<div id="u11" class="ax_text_field">
<input ref="pass" id="u11_input" type="password" />
</div>
<div id="u12" class="ax_shape">
<img id="u12_img" class="img " src="i/images/user_login_page/u12.png"/>
<div id="u13" class="text">
<p><span>账号</span></p>
</div>
</div>
<div id="u14" class="ax_shape">
<img id="u14_img" class="img " src="i/images/user_login_page/u12.png"/>
<div id="u15" class="text">
<p><span>密码</span></p>
</div>
</div>
<div id="u16" class="ax_paragraph">
<img id="u16_img" class="img " src="i/resources/images/transparent.gif"/>
<div id="u17" class="text">
<p><span>找回密码</span></p>
</div>
</div>
<div id="u18" class="ax_paragraph">
<img id="u18_img" class="img " src="i/resources/images/transparent.gif"/>
<div id="u19" class="text">
<p><span></span></p>
</div>
</div>
<div id="u20" class="ax_paragraph">
<img id="u20_img" class="img " src="i/resources/images/transparent.gif"/>
<div id="u21" class="text">
<p><span></span></p>
</div>
</div>
<div id="u22" class="ax_h3">
<img id="u22_img" class="img " src="i/resources/images/transparent.gif"/>
<div id="u23" class="text">
<p><span>会员登录</span></p>
</div>
</div>
<Link to = '/index_home'>
<div id="u24" class="ax_shape">
<img id="u24_img" class="img " src="i/images/user_check_operation_reservation_page/u23.png"/>
<div id="u25" class="text">
<p><span></span></p>
</div>
</div>
</Link>
<div id="u26" class="ax_shape" onClick={this.handleSubmit} >
<img id="u26_img" class="img " src="i/images/user_login_page/u26.png"/>
<div id="u27" class="text">
<p ><span >登录</span></p>
</div>
</div>
</form>
<div id="u170" className="ax_paragraph">
<img id="u170_img" className="img " src="i/resources/images/transparent.gif"/>
<div id="u171" className="text">
<p><span><Link to = {auth.get_config()['about_us_url']}>关于我们</Link></span></p>
</div>
</div>
<div id="u172" className="ax_paragraph">
<img id="u172_img" className="img " src="i/resources/images/transparent.gif"/>
<div id="u173" className="text">
<p><span><Link to = {auth.get_config()['connect_us_url']}>联系我们</Link></span></p>
</div>
</div>
<div id="u174" className="ax_paragraph">
<img id="u174_img" className="img " src="i/resources/images/transparent.gif"/>
<div id="u175" className="text">
<p><span>服务条款</span></p>
</div>
</div>
<div id="u888" className="ax_paragraph" style = {{
'position':'absolute',
'left':'450px',
'top':'530px',
'width':'200px',
'height':'1px',
'font-size':'14px',
'color':'#666666'
}}>
<img id="u125_img" className="img " src="i/resources/images/transparent.gif"/>
<div id="u126" className="text">
<p><span><a href = 'http://www.miitbeian.gov.cn'> 京ICP备案16059247号</a></span></p>
<p><span><img src = 'http://www.beian.gov.cn/img/ghs.png'/><a href = 'http://www.beian.gov.cn/portal/registerSystemInfo?recordcode=11010802022799'>京公网安备 11010802022799号</a></span></p>
</div>
</div>
<div id="u176" className="ax_paragraph">
<img id="u176_img" className="img " src="i/resources/images/transparent.gif"/>
<div id="u177" className="text">
<p><span>媒体更新</span></p>
</div>
<div id="u194" class="ax_html_button">
<input />
</div>
</div>
</div>
</div>
);
}
}));
export default Login; |
require('nodeunit');
var Soteria = require('../lib/soteria.js');
var MockServer = require('./mock_server.js');
var utils = require('./utils.js');
var testServer = new MockServer();
var candidateServer = new MockServer();
var config = require('config');
var candidatePort = config.get("candidate.port");
var originPort = config.get("origin.port");
var testReqOptions = {
hostname: 'localhost',
port: 8080,
headers: {'Content-Type':'application/json'}
};
var requestLogPath = 'request.log';
var server;
exports.setup = function(test) {
server = new Soteria();
server.start();
testServer.start(originPort);
candidateServer.start(candidatePort);
test.done();
};
exports.test1 = {
setUp: function(callback) {
utils.emptyLogs(requestLogPath, function() {
callback();
});
},
gets: {
testEmptyPath: function (test) {
testReqOptions.method = "GET";
testReqOptions.path = "";
utils.createRequest(testReqOptions, utils.verifyBasePath(test)).end();
},
testDefaultPath: function (test) {
testReqOptions.method = "GET";
utils.createRequest(testReqOptions, utils.verifyBasePath(test)).end();
},
testBasePath: function (test) {
testReqOptions.method = "GET";
testReqOptions.path = "/";
utils.createRequest(testReqOptions, utils.verifyBasePath(test)).end();
},
testGet: function (test) {
testReqOptions.method = "GET";
testReqOptions.path = "/glossary";
var verify = function(data) {
test.ok(data);
test.ok(data.glossary);
test.equal(data.glossary.title,'example glossary');
utils.verifyLogData(test);
};
utils.createRequest(testReqOptions, verify).end();
}
}
};
exports.teardown = function(test) {
server.stop();
testServer.stop();
candidateServer.stop();
test.done();
};
|
athens.alert = (function () {
var messageTypes = {
success: {
glyphicon: 'glyphicon-ok',
bootstrapType: 'success'
},
wait: {
glyphicon: 'glyphicon-time',
bootstrapType: 'info'
},
info: {
glyphicon: 'glyphicon-exclamation-sign',
bootstrapType: 'info'
},
error: {
glyphicon: 'glyphicon-remove',
bootstrapType: 'danger'
},
};
var DelayedAlert = function(message, type, duration, delay)
{
var alert = undefined;
this.timeout = window.setTimeout(
function() {
alert = makeAlert(message, type, duration);
},
delay
);
this.close = function() {
window.clearTimeout(this.timeout);
if (typeof alert !== 'undefined') {
alert.close();
}
};
return this;
};
/**
* Creates an alert div, appends it to the notification area, and schedules it for removal.
*
* @param {string} message The message to be displayed on the alert.
* @param {string} type The type of the message, likely "success", or "failure".
* @param {number} duration How long to leave the alert displayed, in milliseconds.
* @param {number} delay How long to wait to display the alert, in milliseconds.
*/
var makeAlert = function(message, type, duration, delay)
{
if (typeof duration === 'undefined') {
duration = 5000;
}
if (typeof delay === 'undefined') {
delay = 0;
}
if (delay > 0) {
return DelayedAlert(message, type, duration, delay);
} else {
var messageType = messageTypes[type];
return $.notify({
icon: 'glyphicon ' + messageType.glyphicon,
message: message
},{
type: messageType.bootstrapType,
animate: {
enter: 'animated fadeInDown',
exit: 'animated fadeOutUp'
},
delay: duration
});
}
};
return {
makeAlert: makeAlert
};
}());
// MagicFAQ.notify = (function () {
//
//
//
// var DelayedNotification = function(message, type, duration, delay)
// {
// var notification = undefined;
//
// this.timeout = window.setTimeout(
// function() {
// notification = notify(message, type, duration);
// },
// delay
// );
//
// this.close = function() {
// window.clearTimeout(this.timeout);
//
// if (typeof notification !== 'undefined') {
// notification.close();
// }
// };
//
// return this;
// };
//
// var notify = function(message, type, duration, delay)
// {
// if (typeof duration === 'undefined') {
// duration = 5000;
// }
//
// if (typeof delay === 'undefined') {
// delay = 0;
// }
//
// if (delay > 0) {
// return DelayedNotification(message, type, duration, delay);
// } else {
// var messageType = messageTypes[type];
//
// return $.notify({
// icon: 'glyphicon ' + messageType.glyphicon,
// message: message
// },{
// type: messageType.bootstrapType,
// animate: {
// enter: 'animated fadeInDown',
// exit: 'animated fadeOutUp'
// },
// delay: duration
// });
// }
// };
//
// return notify;
//
// }());
//
//
//
//
//
|
const JKISS31 = require('../jkiss');
const {newBlock, clearBlock, shuffleInPlace, matrixFloodFill} = require('./util');
// Block properties
// Non-solid: Null color blocks act as air.
// Solid: The block can be swapped with other blocks and air and is displayed displayed by the UI.
// Floating: If a block has air under it, it will start to float and hang in the air for a while (floatTimer > 1).
// Falling: The float timer has ran out and the block is in free fall one unit per time step (floatTimer in {0, 1}).
// Landed: The block has a solid block beneath it and is no longer in free fall (floatTimer < 0).
// Flashing: The block is part of a match (of 3 or more) and will soon turn into air (flashTimer >= 0).
// Chaining: The block is part of a continuous chain where blocks from a previous match drop into a new match (chaining == true).
// Swapping: The block has begun swapping and is on its way to the new location (swapTimer != 0).
const blocksCanSwap = ((block1, block2, above1, above2) => {
if (!block1 || !block2) {
return false;
}
if (!block1.color && !block2.color) {
return false;
}
if (block1.flashTimer >= 0 || block2.flashTimer >= 0) {
return false;
}
if (block1.floatTimer > 0 || block2.floatTimer > 0) {
return false;
}
if (block1.garbage || block2.garbage) {
return false;
}
// Prevent "zero fall" chains as they're too easy and look weird.
if ((above1 && above1.floatTimer > 0) || (above2 && above2.floatTimer > 0)) {
return false;
}
return true;
});
const blocksMatch = ((block1, block2, bellow1, bellow2) => {
if (!block1 || !block2) {
return false;
}
if (block1.flashTimer >= 0 || block2.flashTimer >= 0) {
return false;
}
if (!block1.color || !block2.color) {
return false;
}
if (block1.swapTimer !== 0 || block2.swapTimer !== 0) {
return false;
}
if (block1.garbage || block2.garbage) {
return false;
}
// Blocks above swapping air are in a limbo.
// They are floating/falling in terms of gravity, but
// are still "supported" by the solid block sliding away underneath.
const block1_floating = block1.floatTimer >= 0;
const block2_floating = block2.floatTimer >= 0;
const bellow1_supporting = bellow1 && bellow1.swapTimer && !bellow1.color;
const bellow2_supporting = bellow2 && bellow2.swapTimer && !bellow2.color;
if ((block1_floating && !bellow1_supporting) || (block2_floating && !bellow2_supporting)){
return false;
}
if (block1.color === block2.color) {
return (!block1.preventMatching && !block2.preventMatching);
}
return false;
});
const handleSwapping = ((state) => {
state.blocks.forEach((block) => {
if (block.swapTimer > 0) {
--block.swapTimer;
} else if (block.swapTimer < 0) {
++block.swapTimer;
}
else {
state.dirty = true;
}
});
});
// Match three or more similar blocks horizontally or vertically
const findMatches = ((state, blocks) => {
if (!state.dirty) {
return false;
}
let matchFound = false;
blocks.forEach((block, i) => {
const bellow = blocks[i + state.width];
const above = blocks[i - state.width];
let left, right, left_bellow, right_bellow;
if (i % state.width > 0) {
left = blocks[i - 1];
left_bellow = blocks[i - 1 + state.width];
}
if (i % state.width < state.width - 1) {
right = blocks[i + 1];
right_bellow = blocks[i + 1 + state.widht];
}
if (
blocksMatch(left, block, left_bellow, bellow) &&
blocksMatch(block, right, bellow, right_bellow)
) {
left.matching = true;
block.matching = true;
right.matching = true;
matchFound = true;
}
if (blocksMatch(bellow, block) && blocksMatch(block, above)) {
above.matching = true;
block.matching = true;
bellow.matching = true;
matchFound = true;
}
});
return matchFound;
});
const invalidateMatches = ((blocks) => {
blocks.forEach((block) => {
if (block.matching) {
block.preventMatching = true;
}
});
});
const clearMatches = ((blocks, includeInvalid) => {
blocks.forEach((block) => {
delete block.matching;
if (includeInvalid) {
delete block.preventMatching;
}
});
});
const pushRow = ((blocks, nextRow, width) => {
for (let i = 0; i < width; ++i) {
blocks.shift();
blocks.push(nextRow[i]);
}
});
// When adding rows we must not create new matches unless forced to.
const addRow = ((state) => {
state.dirty = true;
if (state.nextRow) {
pushRow(state.blocks, state.nextRow, state.width);
// Find matches that are forced and exclude them.
findMatches(state, state.blocks);
invalidateMatches(state.blocks);
clearMatches(state.blocks);
}
const RNG = JKISS31.unserialize(state.RNG);
while (true) {
const nextRow = [];
for (let i = 0; i < state.width; ++i) {
const block = newBlock();
block.color = state.blockTypes[RNG.step() % state.blockTypes.length];
nextRow.push(block);
}
// Make sure that no unnecessary matches would be made when pushing the new row.
const candidateBlocks = state.blocks.slice();
pushRow(candidateBlocks, nextRow, state.width);
const candidateMatches = findMatches(state, candidateBlocks);
clearMatches(candidateBlocks);
if (!candidateMatches) {
state.nextRow = nextRow;
break;
}
}
clearMatches(state.blocks, true);
state.RNG = RNG.serialize();
});
// Fill the grid as balanced as possible.
const refillBlocks = ((state) => {
const blocks = state.blocks;
const blockTypes = state.blockTypes;
state.dirty = true;
state.garbage.length = 0;
blocks.forEach(clearBlock);
blocks.forEach((block, index) => {
block.color = blockTypes[Math.floor(index / 3) % blockTypes.length];
});
const RNG = JKISS31.unserialize(state.RNG);
const random = (() => RNG.step01());
while (true) {
shuffleInPlace(blocks, random);
const matchesFound = findMatches(state, blocks);
clearMatches(blocks);
if (!matchesFound) {
break;
}
}
state.RNG = RNG.serialize();
});
const handleEvents = ((state, events) => {
const effects = [];
const garbage = state.garbage;
const blocks = state.blocks;
const isActive = blocks.some((block) => (
block.flashTimer >= 0 ||
block.floatTimer >= 0 ||
block.swapTimer
));
events = events.slice().sort((e1, e2) => {
if (e1.type < e2.type) {
return -1;
} else if (e1.type > e2.type) {
return 1;
}
return e1.index - e2.index;
});
if (events.find((event) => event.type === 'clearAll')) {
blocks.forEach(clearBlock);
garbage.length = 0;
}
events.forEach((event) => {
if (event.type === 'swap') {
const index = event.index
if (index % state.width < state.width - 1) {
const block1 = blocks[index];
const block2 = blocks[index + 1];
const above1 = blocks[index - state.width];
const above2 = blocks[index + 1 - state.width];
if (blocksCanSwap(block1, block2, above1, above2)) {
// Upon swapping the blocks immediately warp into their new locations,
// but receive a swap timer that partially disable them for a while.
// The UI will display this time as a sliding animation.
// Block 1 goes left to right
block1.swapTimer = state.swapTime;
// Block 2 goes right to left
block2.swapTimer = -state.swapTime;
blocks[index] = block2;
blocks[index + 1] = block1;
}
}
} else if (event.type === 'addRow' && (state.addRowWhileActive || !isActive)) {
if (blocks.slice(0, state.width).every(block => !block.color)) {
addRow(state);
garbage.forEach(slab => ++slab.y);
effects.push({type: 'addRow'});
} else {
effects.push({type: 'gameOver'});
}
} else if (event.type === 'addGarbage') {
const slab = Object.assign({}, event.slab);
if (slab.x + slab.width > state.width) {
throw new Error('Invalid garbage slab');
}
// Place the slab on top of all the other slabs or at the top of the screen.
slab.y = garbage.reduce(
(max, s) => Math.max(max, s.y + s.height),
state.height
);
slab.flashTime = state.garbageFlashTime * slab.width * slab.height;
slab.flashTimer = -1;
garbage.push(slab);
}
});
if (events.find((event) => event.type === 'refill')) {
refillBlocks(state);
}
return effects;
});
const handleGravity = ((state) => {
const effects = [];
const blocks = state.blocks;
for (let i = blocks.length - 1; i >= 0; --i) {
const block = blocks[i];
if (!block.color || block.garbage) {
continue;
}
// Floating and falling:
// A block can float or fall if
// it is not at ground level and
// it is not flashing
// and the (solid) block bellow is not swapping and
// either beneath there's air or a floating/falling block.
// Swapping blocks start floating, but wait until
// the swap completes before continuing with the fall.
// Having floatTimer === 1 signals that the block has just
// recently started falling and cannot be swapped.
const bellow = blocks[i + state.width];
if (
bellow &&
(block.flashTimer < 0) &&
(!bellow.color || !bellow.swapTimer) &&
(!bellow.color || bellow.floatTimer >= 0)
) {
if (block.floatTimer < 0) {
if (bellow.color && !block.swapTimer) {
block.floatTimer = bellow.floatTimer;
} else {
block.floatTimer = state.floatTime + 1;
}
block.chaining = (block.chaining || bellow.chaining);
} else if (block.floatTimer === 0 || block.floatTimer === 1) {
// Inherit the timer when falling onto a floating block.
// Only fall through air.
if (bellow.color) {
block.floatTimer = bellow.floatTimer;
} else {
blocks[i] = bellow;
blocks[i + state.width] = block;
}
}
} else {
if (block.floatTimer >= 0) {
effects.push({type: "blockLanded", index: i});
}
block.floatTimer = -1;
}
}
if (effects.length) {
state.dirty = true;
}
return effects;
});
const handleChaining = ((state) => {
if (!state.dirty) {
return;
}
// Flood-fills are expensive so we convert into
// matrix form and back to make it faster.
const source = [];
const target = [];
for (let i = 0; i < state.height; ++i) {
const sourceRow = [];
const targetRow = [];
for (let j = 0; j < state.width; ++j) {
const block = state.blocks[j + i * state.width];
sourceRow.push(block.chaining && block.matching);
targetRow.push(block.matching)
}
source.push(sourceRow);
target.push(targetRow);
}
matrixFloodFill(source, target);
for (let i = 0; i < state.height; ++i) {
for (let j = 0; j < state.width; ++j) {
if (source[i][j]) {
const block = state.blocks[j + i * state.width];
block.chaining = true;
}
}
}
});
const handleTimers = ((state) => {
// TODO: Extend effects to include information required to play game sounds.
const blocks = state.blocks;
const effects = [];
let matchMade = false;
let chainMatchMade = false;
const wasChaining = blocks.some((block) => block.chaining);
const indicesMatched = [];
blocks.forEach((block, i) => {
const above = blocks[i - state.width];
const bellow = blocks[i + state.width];
if (!block.color) {
block.chaining = false;
}
// Chaining ends when a block
// lands and
// is not flashing and
// is not matching and
// is not swapping and
// is not on top of a swapping block.
if (
block.floatTimer < 0 &&
block.flashTimer < 0 &&
!block.swapTimer &&
!block.matching &&
(!bellow || !bellow.swapTimer)
) {
block.chaining = false;
}
if (block.floatTimer > 0) {
--block.floatTimer;
}
if (!--block.flashTimer) {
clearBlock(block);
if (above && above.color) {
above.chaining = true;
above.floatTimer = state.floatTime + 1;
}
effects.push({
type: "flashDone",
index: i,
});
}
if (block.matching) {
block.flashTimer = state.flashTime;
matchMade = true;
indicesMatched.push(i);
if (block.chaining) {
chainMatchMade = true;
}
}
});
clearMatches(blocks);
const isChaining = blocks.some((block) => block.chaining);
if (wasChaining && !isChaining) {
effects.push({
type: "chainDone",
chainNumber: state.chainNumber,
});
state.chainNumber = 0;
}
if (chainMatchMade) {
state.chainNumber++;
effects.push({
type: "chainMatchMade",
chainNumber: state.chainNumber,
indices: indicesMatched,
});
}
else if (matchMade) {
effects.push({
type: "matchMade",
chainNumber: state.chainNumber,
indices: indicesMatched,
});
}
return effects;
});
module.exports = {
handleSwapping,
findMatches,
clearMatches,
addRow,
handleEvents,
handleGravity,
handleChaining,
handleTimers,
};
|
'use strict';
/* Filters */
// Nothing change here, at the moment.
var simulationApp = angular.module('simulationApp.filters', []);
simulationApp.filter('interpolate', ['version', function(version) {
return function(text) {
return String(text).replace(/\%VERSION\%/mg, version);
};
}]);
|
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "/";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 203);
/******/ })
/************************************************************************/
/******/ ({
/***/ 203:
/***/ (function(module, exports, __webpack_require__) {
module.exports = __webpack_require__(204);
/***/ }),
/***/ 204:
/***/ (function(module, exports) {
function menuFunctionality() {
var mainNav = $('.main-nav');
var body = $("html, body");
// On click of the nav button show the navigation.
// $('header .navbar-header button').click(function() {
// $(mainNav).addClass('showing');
// });
$('.navbar-header button').click(function () {
if ($(mainNav).hasClass('showing')) {
$(mainNav).removeClass('showing');
} else {
$(mainNav).addClass('showing');
}
});
// Close the navbar.
$('.main-nav button.close').click(function () {
$(mainNav).removeClass('showing');
});
// Menu links.
$('[data-nav-ref]').click(function (e) {
e.preventDefault();
// Hide the navbar.
$(mainNav).removeClass('showing');
// Get the tag.
var ref = $(this).attr('href');
// Animate the scrollation. SCROLLATION?
if (ref.length > 0) {
body.stop().animate({
scrollTop: $(ref)[0].offsetTop
}, 500, 'swing', function () {
// Finished animation.
});
}
});
}
/**
* Sidebar functionality.
*
*/
function sidebarFunctionality() {
// Get the heights of each section.
var sectionInfo = [];
// Store the current section that we're on!.
var currentSection = "";
// Get the navigation title element.
var navigationTitle = $('.navbar-header .nav-current-section');
// Get the sidebar elements.
var sidebarElements = $('.main-sidebar ul > li');
// Loop through each section.
var sections = $('[section-name]');
console.log(sections);
for (var key in sections) {
// Valid property and not inherited?
if (!isNaN(key) && sections.hasOwnProperty(key)) {
var element = sections[key];
// Get information for each of the sections.
var obj = {};
obj.name = $(element).attr('section-name');
obj.topPos = $(element).offset().top;
obj.botPos = $(element).offset().top + $(element).outerHeight(true);
obj.height = $(element).outerHeight(true);
// Add this to the array.
sectionInfo.push(obj);
}
}
}
function faqQuestionSetup() {
$(document).on('click', '.faqs a', function () {
var questionRef = $(this).attr('data-question-ref');
var answer;
switch (questionRef) {
case "1":
answer = "On site parking is available. Where possible, please car share. Pay and Display parking is available across the street.";
break;
case "2":
answer = "You’ll find out on the day :D";
break;
case "3":
answer = "Ticket releases will be announced here and on @techlincs";
break;
case "4":
answer = "Yes. You can team up with friends or other hackers on the day, or you can hack solo. Only one prize per team member per challenge and each challenge has a maximum of four prizes. A maximum of 4 members per team (you can have more than 4 but there are only 4 prizes)";
break;
case "5":
answer = "Anything created remains the property of the hacker (author). LincolnHack and its sponsors have no ownership over anything you create.";
break;
case "6":
answer = "No… indeed, we strongly advise you get some sleep and stay hydrated. You’re allowed to go home. Come and go as you please. Remember to take regular breaks. Rest is important.";
break;
case "7":
answer = "You will need to provide a ticket for entry. No ticket, no entry.";
break;
case "8":
answer = "TBA - all catering is provided by Sam Owen of Salted Orange. The same great chef from last year.";
break;
default:
console.log("Error");
}
// $(".speech-bubble p").text(answer).animate({opacity:1});
$(".speech-bubble p").animate({ opacity: 0 }, function () {
$(this).text(answer).animate({ opacity: 1 });
});
// Move the eyes right
// $('.eyes').css('left', '23px');
$('.eyes').css('top', '-246px');
$('.nose').css('top', '-253px');
$('footer .imp, footer .eyes, footer .mouth-open, footer .mouth-oo, footer .laptop-glow, footer .nose').css('transform', 'rotate(2deg)');
setTimeout(function () {
setTimeout(function () {
$('.mouth-open').hide();
$('.mouth-oo').show();
}, 200);
$('footer .imp, footer .eyes, footer .mouth-open, footer .mouth-oo, footer .laptop-glow, footer .nose').css('transform', 'rotate(0deg)');
}, 300);
$('.laptop-glow').show();
// Wait a second and return
setTimeout(function () {
$('.eyes').css('top', '-250px');
setTimeout(function () {
$('.nose').css('top', '-250px');
}, 200);
setTimeout(function () {
$('.mouth-open').show();
$('.mouth-oo').hide();
}, 500);
setTimeout(function () {
$('.laptop-glow').hide();
}, 500);
}, 2000);
});
}
function impWatch() {
$('.faqs a').on('mouseenter', function () {
if ($('.eyes').css('top') == '-250px') {
$('.eyes').animate({
top: '-258px',
left: '19px'
}, "slow");
}
});
$('.faqs a').on('mouseleave', function () {
$('.eyes').animate({
top: '-250px',
left: 'initial'
}, "slow");
});
}
function videoPlay() {
$(document).on('click', '.video-control', function () {
if ($(this).hasClass('play')) {
$('.what video').get(0).play();
$(this).removeClass('play').addClass('pause');
} else {
$('.what video').get(0).pause();
$(this).removeClass('pause').addClass('play');
}
});
}
function setupTicker() {
setTimeout(function () {
highlight();
setupTicker();
}, 1300);
}
function highlight() {
if ($('.highlighted').length == 0) {
$('li.first').addClass('highlighted');
} else {
var highlightedElement = $('li.highlighted');
highlightedElement.removeClass('highlighted');
highlightedElement.next('li').addClass('highlighted');
}
}
$(function () {
menuFunctionality();
sidebarFunctionality();
impWatch();
faqQuestionSetup();
videoPlay();
// setupTicker();
});
/***/ })
/******/ }); |
/*!
* engine-assemble <https://github.com/doowb/engine-assemble>
*
* Copyright (c) 2014-2015, Brian Woodward.
* Licensed under the MIT License.
*/
'use strict';
var fs = require('fs');
var path = require('path');
var handlebars = require('..');
var assert = require('assert');
describe('.renderSync()', function () {
it('should render templates.', function () {
var str = handlebars.renderSync('Jon {{ name }}', {name: 'Schlinkert'});
assert.equal(str, 'Jon Schlinkert');
});
});
describe('.render()', function() {
it('should render templates.', function(done) {
var ctx = {name: 'Jon Schlinkert'};
handlebars.render('{{ name }}', ctx, function (err, content) {
assert.equal(content, 'Jon Schlinkert');
done();
});
});
it('should use default helpers.', function (done) {
var ctx = {
name: 'brian woodward'
};
handlebars.render('{{capitalizeEach name}}', ctx, function (err, content) {
if (err) console.log(err);
assert.equal(content, 'Brian Woodward');
done();
});
});
it('should use helpers passed on the options.', function(done) {
var ctx = {
name: 'Jon Schlinkert',
helpers: {
include: function(name) {
var filepath = path.join('test/fixtures', name);
return fs.readFileSync(filepath, 'utf8');
},
upper: function(str) {
return str.toUpperCase();
}
}
};
handlebars.render('{{upper (include "content.hbs")}}', ctx, function (err, content) {
if (err) console.log(err);
assert.equal(content, 'JON SCHLINKERT');
done();
});
});
it('should use helpers on options over default helpers.', function (done) {
var ctx = {
name: 'brian woodward',
helpers: {
capitalizeEach: function (str) {
return str.toUpperCase();
}
}
};
handlebars.render('{{capitalizeEach name}}', ctx, function (err, content) {
if (err) console.log(err);
assert.equal(content, 'BRIAN WOODWARD');
done();
});
});
it('should use partials passed on the options.', function(done) {
var ctx = {
partials: {
a: 'foo',
b: 'bar'
}
};
handlebars.render('{{> a }}{{> b }}', ctx, function (err, content) {
if (err) console.log(err);
assert.equal(content, 'foobar');
done();
});
});
});
describe('.renderFile()', function() {
it('should render templates from a file.', function(done) {
var ctx = {name: 'Jon Schlinkert'};
handlebars.renderFile('test/fixtures/default.hbs', ctx, function (err, content) {
assert.equal(content, 'Jon Schlinkert');
done();
});
});
});
|
'use strict';
const express = require('express');
const router = express.Router();
const bodyParser = require('body-parser');
const request = require('request');
const models = require('../../db/models');
const config = require('config')['News'];
module.exports.getAll = (req, res) => {
models.User.where({ email: req.user.email }).fetch()
.then((result) => {
models.Stats.where({ city: result.attributes.destination }).fetch()
.then((data) => {
if (result.attributes.destination === 'san-francisco-bay-area') {
result.attributes.destination = 'sanfrancisco';
}
request.get({
url: 'https://api.nytimes.com/svc/search/v2/articlesearch.json',
qs: {
'api-key': `${config.APIKey}`,
'q': result.attributes.destination,
'sort': 'newest'
}
}, function(err, response, body) {
if ( typeof body === 'undefined' ) {
res.send({});
}
var body = JSON.parse(body);
let news;
try {
news = body.response.docs;
} catch (exception) {
console.log(exception);
}
var newsData = {};
var dataLength = 10;
var currentIndex = 0;
var validData = true;
if ( typeof news === 'undefined' ) {
res.send({});
} else {
while (news.length > 0 && dataLength > 0 && validData) {
var newsObj = {};
newsObj['headline'] = news[currentIndex].headline.main;
newsObj['url'] = news[currentIndex].web_url;
newsData[currentIndex] = newsObj;
dataLength--;
if (!news[currentIndex + 1]) {
validData = false;
}
currentIndex++;
}
res.send(newsData);
}
});
});
});
};
|
// Given preorder and inorder traversal of a tree, construct the binary tree.
//
// Note:
// You may assume that duplicates do not exist in the tree.
/**
* Definition for a binary tree node.
* function TreeNode(val) {
* this.val = val;
* this.left = this.right = null;
* }
*/
/**
* @param {number[]} preorder
* @param {number[]} inorder
* @return {TreeNode}
*/
let buildTree = function(preorder, inorder) {
if (preorder.length === 0) {
return null;
}
let rootIndex = findIndex(inorder, root.val);
let leftInorder = inorder.slice(0, rootIndex);
let rightInorder = inorder.slice(rootIndex + 1);
let leftPreorder = preorder.slice(1, leftInorder.length + 1);
let rightPreorder = preorder.slice(leftInorder.length + 1);
return node(preorder[0], buildTree(leftPreorder, leftInorder), buildTree(rightPreorder, rightInorder));
};
function node(val, left, right) {
return { val, left, right };
}
function findIndex(array, value) {
for (let i = 0, n = array.length; i < n; i++) {
if (array[i] === value) {
return i;
}
}
return -1;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.