a quick experiment with looking at curved images of d3 visualizations in browser VR.
adapted from this example at aframe.io
the bl.ocks you see are a few recent ones from @mbostock, to wit:
This file has been truncated, but you can view the full file.
| (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.AFRAME = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){ | |
| 'use strict'; | |
| // For more information about browser field, check out the browser field at https://github.com/substack/browserify-handbook#browser-field. | |
| module.exports = { | |
| // Create a <link> tag with optional data attributes | |
| createLink: function(href, attributes) { | |
| var head = document.head || document.getElementsByTagName('head')[0]; | |
| var link = document.createElement('link'); | |
| link.href = href; | |
| link.rel = 'stylesheet'; | |
| for (var key in attributes) { | |
| if ( ! attributes.hasOwnProperty(key)) { | |
| continue; | |
| } | |
| var value = attributes[key]; | |
| link.setAttribute('data-' + key, value); | |
| } | |
| head.appendChild(link); | |
| }, | |
| // Create a <style> tag with optional data attributes | |
| createStyle: function(cssText, attributes) { | |
| var head = document.head || document.getElementsByTagName('head')[0], | |
| style = document.createElement('style'); | |
| style.type = 'text/css'; | |
| for (var key in attributes) { | |
| if ( ! attributes.hasOwnProperty(key)) { | |
| continue; | |
| } | |
| var value = attributes[key]; | |
| style.setAttribute('data-' + key, value); | |
| } | |
| if (style.sheet) { // for jsdom and IE9+ | |
| style.innerHTML = cssText; | |
| style.sheet.cssText = cssText; | |
| head.appendChild(style); | |
| } else if (style.styleSheet) { // for IE8 and below | |
| head.appendChild(style); | |
| style.styleSheet.cssText = cssText; | |
| } else { // for Chrome, Firefox, and Safari | |
| style.appendChild(document.createTextNode(cssText)); | |
| head.appendChild(style); | |
| } | |
| } | |
| }; | |
| },{}],2:[function(_dereq_,module,exports){ | |
| // shim for using process in browser | |
| var process = module.exports = {}; | |
| var queue = []; | |
| var draining = false; | |
| var currentQueue; | |
| var queueIndex = -1; | |
| function cleanUpNextTick() { | |
| draining = false; | |
| if (currentQueue.length) { | |
| queue = currentQueue.concat(queue); | |
| } else { | |
| queueIndex = -1; | |
| } | |
| if (queue.length) { | |
| drainQueue(); | |
| } | |
| } | |
| function drainQueue() { | |
| if (draining) { | |
| return; | |
| } | |
| var timeout = setTimeout(cleanUpNextTick); | |
| draining = true; | |
| var len = queue.length; | |
| while(len) { | |
| currentQueue = queue; | |
| queue = []; | |
| while (++queueIndex < len) { | |
| if (currentQueue) { | |
| currentQueue[queueIndex].run(); | |
| } | |
| } | |
| queueIndex = -1; | |
| len = queue.length; | |
| } | |
| currentQueue = null; | |
| draining = false; | |
| clearTimeout(timeout); | |
| } | |
| process.nextTick = function (fun) { | |
| var args = new Array(arguments.length - 1); | |
| if (arguments.length > 1) { | |
| for (var i = 1; i < arguments.length; i++) { | |
| args[i - 1] = arguments[i]; | |
| } | |
| } | |
| queue.push(new Item(fun, args)); | |
| if (queue.length === 1 && !draining) { | |
| setTimeout(drainQueue, 0); | |
| } | |
| }; | |
| // v8 likes predictible objects | |
| function Item(fun, array) { | |
| this.fun = fun; | |
| this.array = array; | |
| } | |
| Item.prototype.run = function () { | |
| this.fun.apply(null, this.array); | |
| }; | |
| process.title = 'browser'; | |
| process.browser = true; | |
| process.env = {}; | |
| process.argv = []; | |
| process.version = ''; // empty string to avoid regexp issues | |
| process.versions = {}; | |
| function noop() {} | |
| process.on = noop; | |
| process.addListener = noop; | |
| process.once = noop; | |
| process.off = noop; | |
| process.removeListener = noop; | |
| process.removeAllListeners = noop; | |
| process.emit = noop; | |
| process.binding = function (name) { | |
| throw new Error('process.binding is not supported'); | |
| }; | |
| process.cwd = function () { return '/' }; | |
| process.chdir = function (dir) { | |
| throw new Error('process.chdir is not supported'); | |
| }; | |
| process.umask = function() { return 0; }; | |
| },{}],3:[function(_dereq_,module,exports){ | |
| /** | |
| * This is the web browser implementation of `debug()`. | |
| * | |
| * Expose `debug()` as the module. | |
| */ | |
| exports = module.exports = _dereq_('./debug'); | |
| exports.log = log; | |
| exports.formatArgs = formatArgs; | |
| exports.save = save; | |
| exports.load = load; | |
| exports.useColors = useColors; | |
| exports.storage = 'undefined' != typeof chrome | |
| && 'undefined' != typeof chrome.storage | |
| ? chrome.storage.local | |
| : localstorage(); | |
| /** | |
| * Colors. | |
| */ | |
| exports.colors = [ | |
| 'lightseagreen', | |
| 'forestgreen', | |
| 'goldenrod', | |
| 'dodgerblue', | |
| 'darkorchid', | |
| 'crimson' | |
| ]; | |
| /** | |
| * Currently only WebKit-based Web Inspectors, Firefox >= v31, | |
| * and the Firebug extension (any Firefox version) are known | |
| * to support "%c" CSS customizations. | |
| * | |
| * TODO: add a `localStorage` variable to explicitly enable/disable colors | |
| */ | |
| function useColors() { | |
| // is webkit? http://stackoverflow.com/a/16459606/376773 | |
| return ('WebkitAppearance' in document.documentElement.style) || | |
| // is firebug? http://stackoverflow.com/a/398120/376773 | |
| (window.console && (console.firebug || (console.exception && console.table))) || | |
| // is firefox >= v31? | |
| // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages | |
| (navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31); | |
| } | |
| /** | |
| * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. | |
| */ | |
| exports.formatters.j = function(v) { | |
| return JSON.stringify(v); | |
| }; | |
| /** | |
| * Colorize log arguments if enabled. | |
| * | |
| * @api public | |
| */ | |
| function formatArgs() { | |
| var args = arguments; | |
| var useColors = this.useColors; | |
| args[0] = (useColors ? '%c' : '') | |
| + this.namespace | |
| + (useColors ? ' %c' : ' ') | |
| + args[0] | |
| + (useColors ? '%c ' : ' ') | |
| + '+' + exports.humanize(this.diff); | |
| if (!useColors) return args; | |
| var c = 'color: ' + this.color; | |
| args = [args[0], c, 'color: inherit'].concat(Array.prototype.slice.call(args, 1)); | |
| // the final "%c" is somewhat tricky, because there could be other | |
| // arguments passed either before or after the %c, so we need to | |
| // figure out the correct index to insert the CSS into | |
| var index = 0; | |
| var lastC = 0; | |
| args[0].replace(/%[a-z%]/g, function(match) { | |
| if ('%%' === match) return; | |
| index++; | |
| if ('%c' === match) { | |
| // we only are interested in the *last* %c | |
| // (the user may have provided their own) | |
| lastC = index; | |
| } | |
| }); | |
| args.splice(lastC, 0, c); | |
| return args; | |
| } | |
| /** | |
| * Invokes `console.log()` when available. | |
| * No-op when `console.log` is not a "function". | |
| * | |
| * @api public | |
| */ | |
| function log() { | |
| // this hackery is required for IE8/9, where | |
| // the `console.log` function doesn't have 'apply' | |
| return 'object' === typeof console | |
| && console.log | |
| && Function.prototype.apply.call(console.log, console, arguments); | |
| } | |
| /** | |
| * Save `namespaces`. | |
| * | |
| * @param {String} namespaces | |
| * @api private | |
| */ | |
| function save(namespaces) { | |
| try { | |
| if (null == namespaces) { | |
| exports.storage.removeItem('debug'); | |
| } else { | |
| exports.storage.debug = namespaces; | |
| } | |
| } catch(e) {} | |
| } | |
| /** | |
| * Load `namespaces`. | |
| * | |
| * @return {String} returns the previously persisted debug modes | |
| * @api private | |
| */ | |
| function load() { | |
| var r; | |
| try { | |
| r = exports.storage.debug; | |
| } catch(e) {} | |
| return r; | |
| } | |
| /** | |
| * Enable namespaces listed in `localStorage.debug` initially. | |
| */ | |
| exports.enable(load()); | |
| /** | |
| * Localstorage attempts to return the localstorage. | |
| * | |
| * This is necessary because safari throws | |
| * when a user disables cookies/localstorage | |
| * and you attempt to access it. | |
| * | |
| * @return {LocalStorage} | |
| * @api private | |
| */ | |
| function localstorage(){ | |
| try { | |
| return window.localStorage; | |
| } catch (e) {} | |
| } | |
| },{"./debug":4}],4:[function(_dereq_,module,exports){ | |
| /** | |
| * This is the common logic for both the Node.js and web browser | |
| * implementations of `debug()`. | |
| * | |
| * Expose `debug()` as the module. | |
| */ | |
| exports = module.exports = debug; | |
| exports.coerce = coerce; | |
| exports.disable = disable; | |
| exports.enable = enable; | |
| exports.enabled = enabled; | |
| exports.humanize = _dereq_('ms'); | |
| /** | |
| * The currently active debug mode names, and names to skip. | |
| */ | |
| exports.names = []; | |
| exports.skips = []; | |
| /** | |
| * Map of special "%n" handling functions, for the debug "format" argument. | |
| * | |
| * Valid key names are a single, lowercased letter, i.e. "n". | |
| */ | |
| exports.formatters = {}; | |
| /** | |
| * Previously assigned color. | |
| */ | |
| var prevColor = 0; | |
| /** | |
| * Previous log timestamp. | |
| */ | |
| var prevTime; | |
| /** | |
| * Select a color. | |
| * | |
| * @return {Number} | |
| * @api private | |
| */ | |
| function selectColor() { | |
| return exports.colors[prevColor++ % exports.colors.length]; | |
| } | |
| /** | |
| * Create a debugger with the given `namespace`. | |
| * | |
| * @param {String} namespace | |
| * @return {Function} | |
| * @api public | |
| */ | |
| function debug(namespace) { | |
| // define the `disabled` version | |
| function disabled() { | |
| } | |
| disabled.enabled = false; | |
| // define the `enabled` version | |
| function enabled() { | |
| var self = enabled; | |
| // set `diff` timestamp | |
| var curr = +new Date(); | |
| var ms = curr - (prevTime || curr); | |
| self.diff = ms; | |
| self.prev = prevTime; | |
| self.curr = curr; | |
| prevTime = curr; | |
| // add the `color` if not set | |
| if (null == self.useColors) self.useColors = exports.useColors(); | |
| if (null == self.color && self.useColors) self.color = selectColor(); | |
| var args = Array.prototype.slice.call(arguments); | |
| args[0] = exports.coerce(args[0]); | |
| if ('string' !== typeof args[0]) { | |
| // anything else let's inspect with %o | |
| args = ['%o'].concat(args); | |
| } | |
| // apply any `formatters` transformations | |
| var index = 0; | |
| args[0] = args[0].replace(/%([a-z%])/g, function(match, format) { | |
| // if we encounter an escaped % then don't increase the array index | |
| if (match === '%%') return match; | |
| index++; | |
| var formatter = exports.formatters[format]; | |
| if ('function' === typeof formatter) { | |
| var val = args[index]; | |
| match = formatter.call(self, val); | |
| // now we need to remove `args[index]` since it's inlined in the `format` | |
| args.splice(index, 1); | |
| index--; | |
| } | |
| return match; | |
| }); | |
| if ('function' === typeof exports.formatArgs) { | |
| args = exports.formatArgs.apply(self, args); | |
| } | |
| var logFn = enabled.log || exports.log || console.log.bind(console); | |
| logFn.apply(self, args); | |
| } | |
| enabled.enabled = true; | |
| var fn = exports.enabled(namespace) ? enabled : disabled; | |
| fn.namespace = namespace; | |
| return fn; | |
| } | |
| /** | |
| * Enables a debug mode by namespaces. This can include modes | |
| * separated by a colon and wildcards. | |
| * | |
| * @param {String} namespaces | |
| * @api public | |
| */ | |
| function enable(namespaces) { | |
| exports.save(namespaces); | |
| var split = (namespaces || '').split(/[\s,]+/); | |
| var len = split.length; | |
| for (var i = 0; i < len; i++) { | |
| if (!split[i]) continue; // ignore empty strings | |
| namespaces = split[i].replace(/\*/g, '.*?'); | |
| if (namespaces[0] === '-') { | |
| exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$')); | |
| } else { | |
| exports.names.push(new RegExp('^' + namespaces + '$')); | |
| } | |
| } | |
| } | |
| /** | |
| * Disable debug output. | |
| * | |
| * @api public | |
| */ | |
| function disable() { | |
| exports.enable(''); | |
| } | |
| /** | |
| * Returns true if the given mode name is enabled, false otherwise. | |
| * | |
| * @param {String} name | |
| * @return {Boolean} | |
| * @api public | |
| */ | |
| function enabled(name) { | |
| var i, len; | |
| for (i = 0, len = exports.skips.length; i < len; i++) { | |
| if (exports.skips[i].test(name)) { | |
| return false; | |
| } | |
| } | |
| for (i = 0, len = exports.names.length; i < len; i++) { | |
| if (exports.names[i].test(name)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * Coerce `val`. | |
| * | |
| * @param {Mixed} val | |
| * @return {Mixed} | |
| * @api private | |
| */ | |
| function coerce(val) { | |
| if (val instanceof Error) return val.stack || val.message; | |
| return val; | |
| } | |
| },{"ms":5}],5:[function(_dereq_,module,exports){ | |
| /** | |
| * Helpers. | |
| */ | |
| var s = 1000; | |
| var m = s * 60; | |
| var h = m * 60; | |
| var d = h * 24; | |
| var y = d * 365.25; | |
| /** | |
| * Parse or format the given `val`. | |
| * | |
| * Options: | |
| * | |
| * - `long` verbose formatting [false] | |
| * | |
| * @param {String|Number} val | |
| * @param {Object} options | |
| * @return {String|Number} | |
| * @api public | |
| */ | |
| module.exports = function(val, options){ | |
| options = options || {}; | |
| if ('string' == typeof val) return parse(val); | |
| return options.long | |
| ? long(val) | |
| : short(val); | |
| }; | |
| /** | |
| * Parse the given `str` and return milliseconds. | |
| * | |
| * @param {String} str | |
| * @return {Number} | |
| * @api private | |
| */ | |
| function parse(str) { | |
| str = '' + str; | |
| if (str.length > 10000) return; | |
| var match = /^((?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(str); | |
| if (!match) return; | |
| var n = parseFloat(match[1]); | |
| var type = (match[2] || 'ms').toLowerCase(); | |
| switch (type) { | |
| case 'years': | |
| case 'year': | |
| case 'yrs': | |
| case 'yr': | |
| case 'y': | |
| return n * y; | |
| case 'days': | |
| case 'day': | |
| case 'd': | |
| return n * d; | |
| case 'hours': | |
| case 'hour': | |
| case 'hrs': | |
| case 'hr': | |
| case 'h': | |
| return n * h; | |
| case 'minutes': | |
| case 'minute': | |
| case 'mins': | |
| case 'min': | |
| case 'm': | |
| return n * m; | |
| case 'seconds': | |
| case 'second': | |
| case 'secs': | |
| case 'sec': | |
| case 's': | |
| return n * s; | |
| case 'milliseconds': | |
| case 'millisecond': | |
| case 'msecs': | |
| case 'msec': | |
| case 'ms': | |
| return n; | |
| } | |
| } | |
| /** | |
| * Short format for `ms`. | |
| * | |
| * @param {Number} ms | |
| * @return {String} | |
| * @api private | |
| */ | |
| function short(ms) { | |
| if (ms >= d) return Math.round(ms / d) + 'd'; | |
| if (ms >= h) return Math.round(ms / h) + 'h'; | |
| if (ms >= m) return Math.round(ms / m) + 'm'; | |
| if (ms >= s) return Math.round(ms / s) + 's'; | |
| return ms + 'ms'; | |
| } | |
| /** | |
| * Long format for `ms`. | |
| * | |
| * @param {Number} ms | |
| * @return {String} | |
| * @api private | |
| */ | |
| function long(ms) { | |
| return plural(ms, d, 'day') | |
| || plural(ms, h, 'hour') | |
| || plural(ms, m, 'minute') | |
| || plural(ms, s, 'second') | |
| || ms + ' ms'; | |
| } | |
| /** | |
| * Pluralization helper. | |
| */ | |
| function plural(ms, n, name) { | |
| if (ms < n) return; | |
| if (ms < n * 1.5) return Math.floor(ms / n) + ' ' + name; | |
| return Math.ceil(ms / n) + ' ' + name + 's'; | |
| } | |
| },{}],6:[function(_dereq_,module,exports){ | |
| 'use strict'; | |
| var isObj = _dereq_('is-obj'); | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| var propIsEnumerable = Object.prototype.propertyIsEnumerable; | |
| function toObject(val) { | |
| if (val === null || val === undefined) { | |
| throw new TypeError('Sources cannot be null or undefined'); | |
| } | |
| return Object(val); | |
| } | |
| function assignKey(to, from, key) { | |
| var val = from[key]; | |
| if (val === undefined || val === null) { | |
| return; | |
| } | |
| if (hasOwnProperty.call(to, key)) { | |
| if (to[key] === undefined || to[key] === null) { | |
| throw new TypeError('Cannot convert undefined or null to object (' + key + ')'); | |
| } | |
| } | |
| if (!hasOwnProperty.call(to, key) || !isObj(val)) { | |
| to[key] = val; | |
| } else { | |
| to[key] = assign(Object(to[key]), from[key]); | |
| } | |
| } | |
| function assign(to, from) { | |
| if (to === from) { | |
| return to; | |
| } | |
| from = Object(from); | |
| for (var key in from) { | |
| if (hasOwnProperty.call(from, key)) { | |
| assignKey(to, from, key); | |
| } | |
| } | |
| if (Object.getOwnPropertySymbols) { | |
| var symbols = Object.getOwnPropertySymbols(from); | |
| for (var i = 0; i < symbols.length; i++) { | |
| if (propIsEnumerable.call(from, symbols[i])) { | |
| assignKey(to, from, symbols[i]); | |
| } | |
| } | |
| } | |
| return to; | |
| } | |
| module.exports = function deepAssign(target) { | |
| target = toObject(target); | |
| for (var s = 1; s < arguments.length; s++) { | |
| assign(target, arguments[s]); | |
| } | |
| return target; | |
| }; | |
| },{"is-obj":7}],7:[function(_dereq_,module,exports){ | |
| 'use strict'; | |
| module.exports = function (x) { | |
| var type = typeof x; | |
| return x !== null && (type === 'object' || type === 'function'); | |
| }; | |
| },{}],8:[function(_dereq_,module,exports){ | |
| /*! (C) WebReflection Mit Style License */ | |
| (function(t,n,r,i){"use strict";function st(e,t){for(var n=0,r=e.length;n<r;n++)gt(e[n],t)}function ot(e){for(var t=0,n=e.length,r;t<n;t++)r=e[t],it(r,w[at(r)])}function ut(e){return function(t){F(t)&&(gt(t,e),st(t.querySelectorAll(E),e))}}function at(e){var t=R.call(e,"is"),n=e.nodeName.toUpperCase(),r=x.call(b,t?m+t.toUpperCase():v+n);return t&&-1<r&&!ft(n,t)?-1:r}function ft(e,t){return-1<E.indexOf(e+'[is="'+t+'"]')}function lt(e){var t=e.currentTarget,n=e.attrChange,r=e.attrName,i=e.target;Y&&(!i||i===t)&&t.attributeChangedCallback&&r!=="style"&&e.prevValue!==e.newValue&&t.attributeChangedCallback(r,n===e[f]?null:e.prevValue,n===e[c]?null:e.newValue)}function ct(e){var t=ut(e);return function(e){$.push(t,e.target)}}function ht(e){G&&(G=!1,e.currentTarget.removeEventListener(p,ht)),st((e.target||n).querySelectorAll(E),e.detail===u?u:o),j&&vt()}function pt(e,t){var n=this;U.call(n,e,t),Z.call(n,{target:n})}function dt(e,t){P(e,t),nt?nt.observe(e,X):(Q&&(e.setAttribute=pt,e[s]=tt(e),e.addEventListener(d,Z)),e.addEventListener(h,lt)),e.createdCallback&&Y&&(e.created=!0,e.createdCallback(),e.created=!1)}function vt(){for(var e,t=0,n=I.length;t<n;t++)e=I[t],S.contains(e)||(n--,I.splice(t--,1),gt(e,u))}function mt(e){throw new Error("A "+e+" type is already registered")}function gt(e,t){var n,r=at(e);-1<r&&(rt(e,w[r]),r=0,t===o&&!e[o]?(e[u]=!1,e[o]=!0,r=1,j&&x.call(I,e)<0&&I.push(e)):t===u&&!e[u]&&(e[o]=!1,e[u]=!0,r=1),r&&(n=e[t+"Callback"])&&n.call(e))}if(i in n)return;var s="__"+i+(Math.random()*1e5>>0),o="attached",u="detached",a="extends",f="ADDITION",l="MODIFICATION",c="REMOVAL",h="DOMAttrModified",p="DOMContentLoaded",d="DOMSubtreeModified",v="<",m="=",g=/^[A-Z][A-Z0-9]*(?:-[A-Z0-9]+)+$/,y=["ANNOTATION-XML","COLOR-PROFILE","FONT-FACE","FONT-FACE-SRC","FONT-FACE-URI","FONT-FACE-FORMAT","FONT-FACE-NAME","MISSING-GLYPH"],b=[],w=[],E="",S=n.documentElement,x=b.indexOf||function(e){for(var t=this.length;t--&&this[t]!==e;);return t},T=r.prototype,N=T.hasOwnProperty,C=T.isPrototypeOf,k=r.defineProperty,L=r.getOwnPropertyDescriptor,A=r.getOwnPropertyNames,O=r.getPrototypeOf,M=r.setPrototypeOf,_=!!r.__proto__,D=r.create||function yt(e){return e?(yt.prototype=e,new yt):this},P=M||(_?function(e,t){return e.__proto__=t,e}:A&&L?function(){function e(e,t){for(var n,r=A(t),i=0,s=r.length;i<s;i++)n=r[i],N.call(e,n)||k(e,n,L(t,n))}return function(t,n){do e(t,n);while((n=O(n))&&!C.call(n,t));return t}}():function(e,t){for(var n in t)e[n]=t[n];return e}),H=t.MutationObserver||t.WebKitMutationObserver,B=(t.HTMLElement||t.Element||t.Node).prototype,j=!C.call(B,S),F=j?function(e){return e.nodeType===1}:function(e){return C.call(B,e)},I=j&&[],q=B.cloneNode,R=B.getAttribute,U=B.setAttribute,z=B.removeAttribute,W=n.createElement,X=H&&{attributes:!0,characterData:!0,attributeOldValue:!0},V=H||function(e){Q=!1,S.removeEventListener(h,V)},$,J=t.requestAnimationFrame||t.webkitRequestAnimationFrame||t.mozRequestAnimationFrame||t.msRequestAnimationFrame||function(e){setTimeout(e,10)},K=!1,Q=!0,G=!0,Y=!0,Z,et,tt,nt,rt,it;M||_?(rt=function(e,t){C.call(t,e)||dt(e,t)},it=dt):(rt=function(e,t){e[s]||(e[s]=r(!0),dt(e,t))},it=rt),j?(Q=!1,function(){var t=L(B,"addEventListener"),n=t.value,r=function(e){var t=new CustomEvent(h,{bubbles:!0});t.attrName=e,t.prevValue=R.call(this,e),t.newValue=null,t[c]=t.attrChange=2,z.call(this,e),this.dispatchEvent(t)},i=function(t,n){var r=this.hasAttribute(t),i=r&&R.call(this,t);e=new CustomEvent(h,{bubbles:!0}),U.call(this,t,n),e.attrName=t,e.prevValue=r?i:null,e.newValue=n,r?e[l]=e.attrChange=1:e[f]=e.attrChange=0,this.dispatchEvent(e)},o=function(e){var t=e.currentTarget,n=t[s],r=e.propertyName,i;n.hasOwnProperty(r)&&(n=n[r],i=new CustomEvent(h,{bubbles:!0}),i.attrName=n.name,i.prevValue=n.value||null,i.newValue=n.value=t[r]||null,i.prevValue==null?i[f]=i.attrChange=0:i[l]=i.attrChange=1,t.dispatchEvent(i))};t.value=function(e,t,u){e===h&&this.attributeChangedCallback&&this.setAttribute!==i&&(this[s]={className:{name:"class",value:this.className}},this.setAttribute=i,this.removeAttribute=r,n.call(this,"propertychange",o)),n.call(this,e,t,u)},k(B,"addEventListener",t)}()):H||(S.addEventListener(h,V),S.setAttribute(s,1),S.removeAttribute(s),Q&&(Z=function(e){var t=this,n,r,i;if(t===e.target){n=t[s],t[s]=r=tt(t);for(i in r){if(!(i in n))return et(0,t,i,n[i],r[i],f);if(r[i]!==n[i])return et(1,t,i,n[i],r[i],l)}for(i in n)if(!(i in r))return et(2,t,i,n[i],r[i],c)}},et=function(e,t,n,r,i,s){var o={attrChange:e,currentTarget:t,attrName:n,prevValue:r,newValue:i};o[s]=e,lt(o)},tt=function(e){for(var t,n,r={},i=e.attributes,s=0,o=i.length;s<o;s++)t=i[s],n=t.name,n!=="setAttribute"&&(r[n]=t.value);return r})),n[i]=function(t,r){c=t.toUpperCase(),K||(K=!0,H?(nt=function(e,t){function n(e,t){for(var n=0,r=e.length;n<r;t(e[n++]));}return new H(function(r){for(var i,s,o,u=0,a=r.length;u<a;u++)i=r[u],i.type==="childList"?(n(i.addedNodes,e),n(i.removedNodes,t)):(s=i.target,Y&&s.attributeChangedCallback&&i.attributeName!=="style"&&(o=R.call(s,i.attributeName),o!==i.oldValue&&s.attributeChangedCallback(i.attributeName,i.oldValue,o)))})}(ut(o),ut(u)),nt.observe(n,{childList:!0,subtree:!0})):($=[],J(function d(){while($.length)$.shift().call(null,$.shift());J(d)}),n.addEventListener("DOMNodeInserted",ct(o)),n.addEventListener("DOMNodeRemoved",ct(u))),n.addEventListener(p,ht),n.addEventListener("readystatechange",ht),n.createElement=function(e,t){var r=W.apply(n,arguments),i=""+e,s=x.call(b,(t?m:v)+(t||i).toUpperCase()),o=-1<s;return t&&(r.setAttribute("is",t=t.toLowerCase()),o&&(o=ft(i.toUpperCase(),t))),Y=!n.createElement.innerHTMLHelper,o&&it(r,w[s]),r},B.cloneNode=function(e){var t=q.call(this,!!e),n=at(t);return-1<n&&it(t,w[n]),e&&ot(t.querySelectorAll(E)),t}),-2<x.call(b,m+c)+x.call(b,v+c)&&mt(t);if(!g.test(c)||-1<x.call(y,c))throw new Error("The type "+t+" is invalid");var i=function(){return f?n.createElement(l,c):n.createElement(l)},s=r||T,f=N.call(s,a),l=f?r[a].toUpperCase():c,c,h;return f&&-1<x.call(b,v+l)&&mt(l),h=b.push((f?m:v)+c)-1,E=E.concat(E.length?",":"",f?l+'[is="'+t.toLowerCase()+'"]':l),i.prototype=w[h]=N.call(s,"prototype")?s.prototype:D(B),st(n.querySelectorAll(E),o),i}})(window,document,Object,"registerElement"); | |
| },{}],9:[function(_dereq_,module,exports){ | |
| /* eslint-disable no-unused-vars */ | |
| 'use strict'; | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| var propIsEnumerable = Object.prototype.propertyIsEnumerable; | |
| function toObject(val) { | |
| if (val === null || val === undefined) { | |
| throw new TypeError('Object.assign cannot be called with null or undefined'); | |
| } | |
| return Object(val); | |
| } | |
| module.exports = Object.assign || function (target, source) { | |
| var from; | |
| var to = toObject(target); | |
| var symbols; | |
| for (var s = 1; s < arguments.length; s++) { | |
| from = Object(arguments[s]); | |
| for (var key in from) { | |
| if (hasOwnProperty.call(from, key)) { | |
| to[key] = from[key]; | |
| } | |
| } | |
| if (Object.getOwnPropertySymbols) { | |
| symbols = Object.getOwnPropertySymbols(from); | |
| for (var i = 0; i < symbols.length; i++) { | |
| if (propIsEnumerable.call(from, symbols[i])) { | |
| to[symbols[i]] = from[symbols[i]]; | |
| } | |
| } | |
| } | |
| } | |
| return to; | |
| }; | |
| },{}],10:[function(_dereq_,module,exports){ | |
| (function (global){ | |
| var performance = global.performance || {}; | |
| var present = (function () { | |
| var names = ['now', 'webkitNow', 'msNow', 'mozNow', 'oNow']; | |
| while (names.length) { | |
| var name = names.shift(); | |
| if (name in performance) { | |
| return performance[name].bind(performance); | |
| } | |
| } | |
| var dateNow = Date.now || function () { return new Date().getTime(); }; | |
| var navigationStart = (performance.timing || {}).navigationStart || dateNow(); | |
| return function () { | |
| return dateNow() - navigationStart; | |
| }; | |
| }()); | |
| present.performanceNow = performance.now; | |
| present.noConflict = function () { | |
| performance.now = present.performanceNow; | |
| }; | |
| present.conflict = function () { | |
| performance.now = present; | |
| }; | |
| present.conflict(); | |
| module.exports = present; | |
| }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) | |
| },{}],11:[function(_dereq_,module,exports){ | |
| (function(root) { | |
| // Store setTimeout reference so promise-polyfill will be unaffected by | |
| // other code modifying setTimeout (like sinon.useFakeTimers()) | |
| var setTimeoutFunc = setTimeout; | |
| // Use polyfill for setImmediate for performance gains | |
| var asap = (typeof setImmediate === 'function' && setImmediate) || | |
| function(fn) { setTimeoutFunc(fn, 1); }; | |
| // Polyfill for Function.prototype.bind | |
| function bind(fn, thisArg) { | |
| return function() { | |
| fn.apply(thisArg, arguments); | |
| } | |
| } | |
| var isArray = Array.isArray || function(value) { return Object.prototype.toString.call(value) === "[object Array]" }; | |
| function Promise(fn) { | |
| if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new'); | |
| if (typeof fn !== 'function') throw new TypeError('not a function'); | |
| this._state = null; | |
| this._value = null; | |
| this._deferreds = [] | |
| doResolve(fn, bind(resolve, this), bind(reject, this)) | |
| } | |
| function handle(deferred) { | |
| var me = this; | |
| if (this._state === null) { | |
| this._deferreds.push(deferred); | |
| return | |
| } | |
| asap(function() { | |
| var cb = me._state ? deferred.onFulfilled : deferred.onRejected | |
| if (cb === null) { | |
| (me._state ? deferred.resolve : deferred.reject)(me._value); | |
| return; | |
| } | |
| var ret; | |
| try { | |
| ret = cb(me._value); | |
| } | |
| catch (e) { | |
| deferred.reject(e); | |
| return; | |
| } | |
| deferred.resolve(ret); | |
| }) | |
| } | |
| function resolve(newValue) { | |
| try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure | |
| if (newValue === this) throw new TypeError('A promise cannot be resolved with itself.'); | |
| if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) { | |
| var then = newValue.then; | |
| if (typeof then === 'function') { | |
| doResolve(bind(then, newValue), bind(resolve, this), bind(reject, this)); | |
| return; | |
| } | |
| } | |
| this._state = true; | |
| this._value = newValue; | |
| finale.call(this); | |
| } catch (e) { reject.call(this, e); } | |
| } | |
| function reject(newValue) { | |
| this._state = false; | |
| this._value = newValue; | |
| finale.call(this); | |
| } | |
| function finale() { | |
| for (var i = 0, len = this._deferreds.length; i < len; i++) { | |
| handle.call(this, this._deferreds[i]); | |
| } | |
| this._deferreds = null; | |
| } | |
| function Handler(onFulfilled, onRejected, resolve, reject){ | |
| this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null; | |
| this.onRejected = typeof onRejected === 'function' ? onRejected : null; | |
| this.resolve = resolve; | |
| this.reject = reject; | |
| } | |
| /** | |
| * Take a potentially misbehaving resolver function and make sure | |
| * onFulfilled and onRejected are only called once. | |
| * | |
| * Makes no guarantees about asynchrony. | |
| */ | |
| function doResolve(fn, onFulfilled, onRejected) { | |
| var done = false; | |
| try { | |
| fn(function (value) { | |
| if (done) return; | |
| done = true; | |
| onFulfilled(value); | |
| }, function (reason) { | |
| if (done) return; | |
| done = true; | |
| onRejected(reason); | |
| }) | |
| } catch (ex) { | |
| if (done) return; | |
| done = true; | |
| onRejected(ex); | |
| } | |
| } | |
| Promise.prototype['catch'] = function (onRejected) { | |
| return this.then(null, onRejected); | |
| }; | |
| Promise.prototype.then = function(onFulfilled, onRejected) { | |
| var me = this; | |
| return new Promise(function(resolve, reject) { | |
| handle.call(me, new Handler(onFulfilled, onRejected, resolve, reject)); | |
| }) | |
| }; | |
| Promise.all = function () { | |
| var args = Array.prototype.slice.call(arguments.length === 1 && isArray(arguments[0]) ? arguments[0] : arguments); | |
| return new Promise(function (resolve, reject) { | |
| if (args.length === 0) return resolve([]); | |
| var remaining = args.length; | |
| function res(i, val) { | |
| try { | |
| if (val && (typeof val === 'object' || typeof val === 'function')) { | |
| var then = val.then; | |
| if (typeof then === 'function') { | |
| then.call(val, function (val) { res(i, val) }, reject); | |
| return; | |
| } | |
| } | |
| args[i] = val; | |
| if (--remaining === 0) { | |
| resolve(args); | |
| } | |
| } catch (ex) { | |
| reject(ex); | |
| } | |
| } | |
| for (var i = 0; i < args.length; i++) { | |
| res(i, args[i]); | |
| } | |
| }); | |
| }; | |
| Promise.resolve = function (value) { | |
| if (value && typeof value === 'object' && value.constructor === Promise) { | |
| return value; | |
| } | |
| return new Promise(function (resolve) { | |
| resolve(value); | |
| }); | |
| }; | |
| Promise.reject = function (value) { | |
| return new Promise(function (resolve, reject) { | |
| reject(value); | |
| }); | |
| }; | |
| Promise.race = function (values) { | |
| return new Promise(function (resolve, reject) { | |
| for(var i = 0, len = values.length; i < len; i++) { | |
| values[i].then(resolve, reject); | |
| } | |
| }); | |
| }; | |
| /** | |
| * Set the immediate function to execute callbacks | |
| * @param fn {function} Function to execute | |
| * @private | |
| */ | |
| Promise._setImmediateFn = function _setImmediateFn(fn) { | |
| asap = fn; | |
| }; | |
| if (typeof module !== 'undefined' && module.exports) { | |
| module.exports = Promise; | |
| } else if (!root.Promise) { | |
| root.Promise = Promise; | |
| } | |
| })(this); | |
| },{}],12:[function(_dereq_,module,exports){ | |
| 'use strict'; | |
| var raf = _dereq_('raf'); | |
| var now = _dereq_('time-now'); | |
| exports = module.exports = interval; | |
| function interval(delay, fn, ctx) { | |
| var start = now(); | |
| var data = Object.create(null); | |
| data.id = raf(loop); | |
| return data; | |
| function loop() { | |
| data.id = raf(loop); | |
| if ((now() - start) >= delay) { | |
| fn.call(ctx); | |
| start = now(); | |
| } | |
| } | |
| } | |
| exports.clear = clearInterval; | |
| function clearInterval(data) { | |
| raf.cancel(data.id); | |
| } | |
| },{"raf":13,"time-now":14}],13:[function(_dereq_,module,exports){ | |
| /** | |
| * Expose `requestAnimationFrame()`. | |
| */ | |
| exports = module.exports = window.requestAnimationFrame | |
| || window.webkitRequestAnimationFrame | |
| || window.mozRequestAnimationFrame | |
| || fallback; | |
| /** | |
| * Fallback implementation. | |
| */ | |
| var prev = new Date().getTime(); | |
| function fallback(fn) { | |
| var curr = new Date().getTime(); | |
| var ms = Math.max(0, 16 - (curr - prev)); | |
| var req = setTimeout(fn, ms); | |
| prev = curr; | |
| return req; | |
| } | |
| /** | |
| * Cancel. | |
| */ | |
| var cancel = window.cancelAnimationFrame | |
| || window.webkitCancelAnimationFrame | |
| || window.mozCancelAnimationFrame | |
| || window.clearTimeout; | |
| exports.cancel = function(id){ | |
| cancel.call(window, id); | |
| }; | |
| },{}],14:[function(_dereq_,module,exports){ | |
| 'use strict'; | |
| module.exports = (function() { | |
| var perf = window && window.performance; | |
| if (perf && perf.now) { | |
| return perf.now.bind(perf); | |
| } else { | |
| return function() { | |
| return new Date().getTime(); | |
| }; | |
| } | |
| }()); | |
| },{}],15:[function(_dereq_,module,exports){ | |
| /* | |
| style-attr | |
| ==== | |
| Very simple parsing and stringifying of style attributes. | |
| `parse` | |
| ---- | |
| Convert a style attribute string to an object. | |
| - input: string (eg. anything you might see in a style attribute) | |
| - return: object | |
| */ | |
| function parse (raw) { | |
| var trim = function (s) { return s.trim(); }; | |
| var obj = {}; | |
| getKeyValueChunks(raw) | |
| .map(trim) | |
| .filter(Boolean) | |
| .forEach(function (item) { | |
| // split with `.indexOf` rather than `.split` because the value may also contain colons. | |
| var pos = item.indexOf(':'); | |
| var key = item.substr(0, pos).trim(); | |
| var val = item.substr(pos + 1).trim(); | |
| obj[key] = val; | |
| }); | |
| return obj; | |
| } | |
| /* | |
| `getKeyValueChunks` | |
| ---- | |
| Split a string into chunks matching `<key>: <value>` | |
| - input: string | |
| - return: Array<string> | |
| */ | |
| function getKeyValueChunks (raw) { | |
| var chunks = []; | |
| var offset = 0; | |
| var sep = ';'; | |
| var hasUnclosedUrl = /url\([^\)]+$/; | |
| var chunk = ''; | |
| var nextSplit; | |
| while (offset < raw.length) { | |
| nextSplit = raw.indexOf(sep, offset); | |
| if (nextSplit === -1) { nextSplit = raw.length; } | |
| chunk += raw.substring(offset, nextSplit); | |
| // data URIs can contain semicolons, so make sure we get the whole thing | |
| if (hasUnclosedUrl.test(chunk)) { | |
| chunk += ';'; | |
| offset = nextSplit + 1; | |
| continue; | |
| } | |
| chunks.push(chunk); | |
| chunk = ''; | |
| offset = nextSplit + 1; | |
| } | |
| return chunks; | |
| } | |
| /* | |
| `stringify` | |
| ---- | |
| Convert an object into an attribute string | |
| - input: object | |
| - return: string | |
| */ | |
| function stringify (obj) { | |
| return Object.keys(obj) | |
| .map(function (key) { | |
| return key + ':' + obj[key]; | |
| }) | |
| .join(';'); | |
| } | |
| /* | |
| `normalize` | |
| ---- | |
| Normalize an attribute string (eg. collapse duplicates) | |
| - input: string | |
| - return: string | |
| */ | |
| function normalize (str) { | |
| return stringify(parse(str)); | |
| } | |
| module.exports.parse = parse; | |
| module.exports.stringify = stringify; | |
| module.exports.normalize = normalize; | |
| },{}],16:[function(_dereq_,module,exports){ | |
| /** | |
| * @author dmarcos / https://github.com/dmarcos | |
| * @author mrdoob / http://mrdoob.com | |
| */ | |
| THREE.VRControls = function ( object, onError ) { | |
| var scope = this; | |
| var vrInputs = []; | |
| function gotVRDevices( devices ) { | |
| for ( var i = 0; i < devices.length; i ++ ) { | |
| if ( devices[ i ] instanceof PositionSensorVRDevice ) { | |
| vrInputs.push( devices[ i ] ); | |
| } | |
| } | |
| if ( vrInputs.length === 0 ) { | |
| if ( onError ) onError( 'PositionSensorVRDevice not available' ); | |
| } | |
| } | |
| if ( navigator.getVRDevices ) { | |
| navigator.getVRDevices().then( gotVRDevices ); | |
| } | |
| // the Rift SDK returns the position in meters | |
| // this scale factor allows the user to define how meters | |
| // are converted to scene units. | |
| this.scale = 1; | |
| this.update = function () { | |
| for ( var i = 0; i < vrInputs.length; i ++ ) { | |
| var vrInput = vrInputs[ i ]; | |
| var state = vrInput.getState(); | |
| if ( state.orientation !== null ) { | |
| object.quaternion.copy( state.orientation ); | |
| } | |
| if ( state.position !== null ) { | |
| object.position.copy( state.position ).multiplyScalar( scope.scale ); | |
| } | |
| } | |
| }; | |
| this.resetSensor = function () { | |
| for ( var i = 0; i < vrInputs.length; i ++ ) { | |
| var vrInput = vrInputs[ i ]; | |
| if ( vrInput.resetSensor !== undefined ) { | |
| vrInput.resetSensor(); | |
| } else if ( vrInput.zeroSensor !== undefined ) { | |
| vrInput.zeroSensor(); | |
| } | |
| } | |
| }; | |
| this.zeroSensor = function () { | |
| console.warn( 'THREE.VRControls: .zeroSensor() is now .resetSensor().' ); | |
| this.resetSensor(); | |
| }; | |
| this.dispose = function () { | |
| vrInputs = []; | |
| }; | |
| }; | |
| },{}],17:[function(_dereq_,module,exports){ | |
| /** | |
| * @author dmarcos / https://github.com/dmarcos | |
| * @author mrdoob / http://mrdoob.com | |
| * | |
| * WebVR Spec: http://mozvr.github.io/webvr-spec/webvr.html | |
| * | |
| * Firefox: http://mozvr.com/downloads/ | |
| * Chromium: https://drive.google.com/folderview?id=0BzudLt22BqGRbW9WTHMtOWMzNjQ&usp=sharing#list | |
| * | |
| */ | |
| THREE.VREffect = function ( renderer, onError ) { | |
| var vrHMD; | |
| var eyeTranslationL, eyeFOVL; | |
| var eyeTranslationR, eyeFOVR; | |
| function gotVRDevices( devices ) { | |
| for ( var i = 0; i < devices.length; i ++ ) { | |
| if ( devices[ i ] instanceof HMDVRDevice ) { | |
| vrHMD = devices[ i ]; | |
| break; // We keep the first we encounter | |
| } | |
| } | |
| if ( vrHMD === undefined ) { | |
| if ( onError ) onError( 'HMD not available' ); | |
| } | |
| } | |
| if ( navigator.getVRDevices ) { | |
| navigator.getVRDevices().then( gotVRDevices ); | |
| } | |
| // | |
| this.scale = 1; | |
| this.setSize = function ( width, height ) { | |
| renderer.setSize( width, height ); | |
| }; | |
| // fullscreen | |
| var isFullscreen = false; | |
| var canvas = renderer.domElement; | |
| var fullscreenchange = canvas.mozRequestFullScreen ? 'mozfullscreenchange' : 'webkitfullscreenchange'; | |
| document.addEventListener( fullscreenchange, function ( event ) { | |
| isFullscreen = document.mozFullScreenElement || document.webkitFullscreenElement; | |
| }, false ); | |
| this.setFullScreen = function ( boolean ) { | |
| if ( vrHMD === undefined ) return; | |
| if ( isFullscreen === boolean ) return; | |
| if ( canvas.mozRequestFullScreen ) { | |
| canvas.mozRequestFullScreen( { vrDisplay: vrHMD } ); | |
| } else if ( canvas.webkitRequestFullscreen ) { | |
| canvas.webkitRequestFullscreen( { vrDisplay: vrHMD } ); | |
| } | |
| }; | |
| // render | |
| var cameraL = new THREE.PerspectiveCamera(); | |
| cameraL.layers.enable( 1 ); | |
| var cameraR = new THREE.PerspectiveCamera(); | |
| cameraR.layers.enable( 2 ); | |
| this.render = function ( scene, camera ) { | |
| if ( vrHMD ) { | |
| var eyeParamsL = vrHMD.getEyeParameters( 'left' ); | |
| var eyeParamsR = vrHMD.getEyeParameters( 'right' ); | |
| eyeTranslationL = eyeParamsL.eyeTranslation; | |
| eyeTranslationR = eyeParamsR.eyeTranslation; | |
| eyeFOVL = eyeParamsL.recommendedFieldOfView; | |
| eyeFOVR = eyeParamsR.recommendedFieldOfView; | |
| if ( Array.isArray( scene ) ) { | |
| console.warn( 'THREE.VREffect.render() no longer supports arrays. Use object.layers instead.' ); | |
| scene = scene[ 0 ]; | |
| } | |
| var size = renderer.getSize(); | |
| renderer.setScissorTest( true ); | |
| renderer.clear(); | |
| if ( camera.parent === null ) camera.updateMatrixWorld(); | |
| cameraL.projectionMatrix = fovToProjection( eyeFOVL, true, camera.near, camera.far ); | |
| cameraR.projectionMatrix = fovToProjection( eyeFOVR, true, camera.near, camera.far ); | |
| camera.matrixWorld.decompose( cameraL.position, cameraL.quaternion, cameraL.scale ); | |
| camera.matrixWorld.decompose( cameraR.position, cameraR.quaternion, cameraR.scale ); | |
| cameraL.translateX( eyeTranslationL.x * this.scale ); | |
| cameraR.translateX( eyeTranslationR.x * this.scale ); | |
| // render left eye | |
| renderer.setViewport( 0, 0, size.width / 2, size.height ); | |
| renderer.setScissor( 0, 0, size.width / 2, size.height ); | |
| renderer.render( scene, cameraL ); | |
| // render right eye | |
| renderer.setViewport( size.width / 2, 0, size.width / 2, size.height ); | |
| renderer.setScissor( size.width / 2, 0, size.width / 2, size.height ); | |
| renderer.render( scene, cameraR ); | |
| renderer.setScissorTest( false ); | |
| return; | |
| } | |
| // Regular render mode if not HMD | |
| renderer.render( scene, camera ); | |
| }; | |
| // | |
| function fovToNDCScaleOffset( fov ) { | |
| var pxscale = 2.0 / ( fov.leftTan + fov.rightTan ); | |
| var pxoffset = ( fov.leftTan - fov.rightTan ) * pxscale * 0.5; | |
| var pyscale = 2.0 / ( fov.upTan + fov.downTan ); | |
| var pyoffset = ( fov.upTan - fov.downTan ) * pyscale * 0.5; | |
| return { scale: [ pxscale, pyscale ], offset: [ pxoffset, pyoffset ] }; | |
| } | |
| function fovPortToProjection( fov, rightHanded, zNear, zFar ) { | |
| rightHanded = rightHanded === undefined ? true : rightHanded; | |
| zNear = zNear === undefined ? 0.01 : zNear; | |
| zFar = zFar === undefined ? 10000.0 : zFar; | |
| var handednessScale = rightHanded ? - 1.0 : 1.0; | |
| // start with an identity matrix | |
| var mobj = new THREE.Matrix4(); | |
| var m = mobj.elements; | |
| // and with scale/offset info for normalized device coords | |
| var scaleAndOffset = fovToNDCScaleOffset( fov ); | |
| // X result, map clip edges to [-w,+w] | |
| m[ 0 * 4 + 0 ] = scaleAndOffset.scale[ 0 ]; | |
| m[ 0 * 4 + 1 ] = 0.0; | |
| m[ 0 * 4 + 2 ] = scaleAndOffset.offset[ 0 ] * handednessScale; | |
| m[ 0 * 4 + 3 ] = 0.0; | |
| // Y result, map clip edges to [-w,+w] | |
| // Y offset is negated because this proj matrix transforms from world coords with Y=up, | |
| // but the NDC scaling has Y=down (thanks D3D?) | |
| m[ 1 * 4 + 0 ] = 0.0; | |
| m[ 1 * 4 + 1 ] = scaleAndOffset.scale[ 1 ]; | |
| m[ 1 * 4 + 2 ] = - scaleAndOffset.offset[ 1 ] * handednessScale; | |
| m[ 1 * 4 + 3 ] = 0.0; | |
| // Z result (up to the app) | |
| m[ 2 * 4 + 0 ] = 0.0; | |
| m[ 2 * 4 + 1 ] = 0.0; | |
| m[ 2 * 4 + 2 ] = zFar / ( zNear - zFar ) * - handednessScale; | |
| m[ 2 * 4 + 3 ] = ( zFar * zNear ) / ( zNear - zFar ); | |
| // W result (= Z in) | |
| m[ 3 * 4 + 0 ] = 0.0; | |
| m[ 3 * 4 + 1 ] = 0.0; | |
| m[ 3 * 4 + 2 ] = handednessScale; | |
| m[ 3 * 4 + 3 ] = 0.0; | |
| mobj.transpose(); | |
| return mobj; | |
| } | |
| function fovToProjection( fov, rightHanded, zNear, zFar ) { | |
| var DEG2RAD = Math.PI / 180.0; | |
| var fovPort = { | |
| upTan: Math.tan( fov.upDegrees * DEG2RAD ), | |
| downTan: Math.tan( fov.downDegrees * DEG2RAD ), | |
| leftTan: Math.tan( fov.leftDegrees * DEG2RAD ), | |
| rightTan: Math.tan( fov.rightDegrees * DEG2RAD ) | |
| }; | |
| return fovPortToProjection( fovPort, rightHanded, zNear, zFar ); | |
| } | |
| }; | |
| },{}],18:[function(_dereq_,module,exports){ | |
| /** | |
| * @author Tim Knip / http://www.floorplanner.com/ / tim at floorplanner.com | |
| * @author Tony Parisi / http://www.tonyparisi.com/ | |
| */ | |
| THREE.ColladaLoader = function () { | |
| var COLLADA = null; | |
| var scene = null; | |
| var visualScene; | |
| var kinematicsModel; | |
| var readyCallbackFunc = null; | |
| var sources = {}; | |
| var images = {}; | |
| var animations = {}; | |
| var controllers = {}; | |
| var geometries = {}; | |
| var materials = {}; | |
| var effects = {}; | |
| var cameras = {}; | |
| var lights = {}; | |
| var animData; | |
| var kinematics; | |
| var visualScenes; | |
| var kinematicsModels; | |
| var baseUrl; | |
| var morphs; | |
| var skins; | |
| var flip_uv = true; | |
| var preferredShading = THREE.SmoothShading; | |
| var options = { | |
| // Force Geometry to always be centered at the local origin of the | |
| // containing Mesh. | |
| centerGeometry: false, | |
| // Axis conversion is done for geometries, animations, and controllers. | |
| // If we ever pull cameras or lights out of the COLLADA file, they'll | |
| // need extra work. | |
| convertUpAxis: false, | |
| subdivideFaces: true, | |
| upAxis: 'Y', | |
| // For reflective or refractive materials we'll use this cubemap | |
| defaultEnvMap: null | |
| }; | |
| var colladaUnit = 1.0; | |
| var colladaUp = 'Y'; | |
| var upConversion = null; | |
| function load ( url, readyCallback, progressCallback, failCallback ) { | |
| var length = 0; | |
| if ( document.implementation && document.implementation.createDocument ) { | |
| var request = new XMLHttpRequest(); | |
| request.onreadystatechange = function() { | |
| if ( request.readyState === 4 ) { | |
| if ( request.status === 0 || request.status === 200 ) { | |
| if ( request.response ) { | |
| readyCallbackFunc = readyCallback; | |
| parse( request.response, undefined, url ); | |
| } else { | |
| if ( failCallback ) { | |
| failCallback(); | |
| } else { | |
| console.error( "ColladaLoader: Empty or non-existing file (" + url + ")" ); | |
| } | |
| } | |
| } | |
| } else if ( request.readyState === 3 ) { | |
| if ( progressCallback ) { | |
| if ( length === 0 ) { | |
| length = request.getResponseHeader( "Content-Length" ); | |
| } | |
| progressCallback( { total: length, loaded: request.responseText.length } ); | |
| } | |
| } | |
| }; | |
| request.open( "GET", url, true ); | |
| request.send( null ); | |
| } else { | |
| alert( "Don't know how to parse XML!" ); | |
| } | |
| } | |
| function parse( text, callBack, url ) { | |
| COLLADA = new DOMParser().parseFromString( text, 'text/xml' ); | |
| callBack = callBack || readyCallbackFunc; | |
| if ( url !== undefined ) { | |
| var parts = url.split( '/' ); | |
| parts.pop(); | |
| baseUrl = ( parts.length < 1 ? '.' : parts.join( '/' ) ) + '/'; | |
| } | |
| parseAsset(); | |
| setUpConversion(); | |
| images = parseLib( "library_images image", _Image, "image" ); | |
| materials = parseLib( "library_materials material", Material, "material" ); | |
| effects = parseLib( "library_effects effect", Effect, "effect" ); | |
| geometries = parseLib( "library_geometries geometry", Geometry, "geometry" ); | |
| cameras = parseLib( "library_cameras camera", Camera, "camera" ); | |
| lights = parseLib( "library_lights light", Light, "light" ); | |
| controllers = parseLib( "library_controllers controller", Controller, "controller" ); | |
| animations = parseLib( "library_animations animation", Animation, "animation" ); | |
| visualScenes = parseLib( "library_visual_scenes visual_scene", VisualScene, "visual_scene" ); | |
| kinematicsModels = parseLib( "library_kinematics_models kinematics_model", KinematicsModel, "kinematics_model" ); | |
| morphs = []; | |
| skins = []; | |
| visualScene = parseScene(); | |
| scene = new THREE.Group(); | |
| for ( var i = 0; i < visualScene.nodes.length; i ++ ) { | |
| scene.add( createSceneGraph( visualScene.nodes[ i ] ) ); | |
| } | |
| // unit conversion | |
| scene.scale.multiplyScalar( colladaUnit ); | |
| createAnimations(); | |
| kinematicsModel = parseKinematicsModel(); | |
| createKinematics(); | |
| var result = { | |
| scene: scene, | |
| morphs: morphs, | |
| skins: skins, | |
| animations: animData, | |
| kinematics: kinematics, | |
| dae: { | |
| images: images, | |
| materials: materials, | |
| cameras: cameras, | |
| lights: lights, | |
| effects: effects, | |
| geometries: geometries, | |
| controllers: controllers, | |
| animations: animations, | |
| visualScenes: visualScenes, | |
| visualScene: visualScene, | |
| scene: visualScene, | |
| kinematicsModels: kinematicsModels, | |
| kinematicsModel: kinematicsModel | |
| } | |
| }; | |
| if ( callBack ) { | |
| callBack( result ); | |
| } | |
| return result; | |
| } | |
| function setPreferredShading ( shading ) { | |
| preferredShading = shading; | |
| } | |
| function parseAsset () { | |
| var elements = COLLADA.querySelectorAll('asset'); | |
| var element = elements[0]; | |
| if ( element && element.childNodes ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| switch ( child.nodeName ) { | |
| case 'unit': | |
| var meter = child.getAttribute( 'meter' ); | |
| if ( meter ) { | |
| colladaUnit = parseFloat( meter ); | |
| } | |
| break; | |
| case 'up_axis': | |
| colladaUp = child.textContent.charAt(0); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| function parseLib ( q, classSpec, prefix ) { | |
| var elements = COLLADA.querySelectorAll(q); | |
| var lib = {}; | |
| var i = 0; | |
| var elementsLength = elements.length; | |
| for ( var j = 0; j < elementsLength; j ++ ) { | |
| var element = elements[j]; | |
| var daeElement = ( new classSpec() ).parse( element ); | |
| if ( !daeElement.id || daeElement.id.length === 0 ) daeElement.id = prefix + ( i ++ ); | |
| lib[ daeElement.id ] = daeElement; | |
| } | |
| return lib; | |
| } | |
| function parseScene() { | |
| var sceneElement = COLLADA.querySelectorAll('scene instance_visual_scene')[0]; | |
| if ( sceneElement ) { | |
| var url = sceneElement.getAttribute( 'url' ).replace( /^#/, '' ); | |
| return visualScenes[ url.length > 0 ? url : 'visual_scene0' ]; | |
| } else { | |
| return null; | |
| } | |
| } | |
| function parseKinematicsModel() { | |
| var kinematicsModelElement = COLLADA.querySelectorAll('instance_kinematics_model')[0]; | |
| if ( kinematicsModelElement ) { | |
| var url = kinematicsModelElement.getAttribute( 'url' ).replace(/^#/, ''); | |
| return kinematicsModels[ url.length > 0 ? url : 'kinematics_model0' ]; | |
| } else { | |
| return null; | |
| } | |
| } | |
| function createAnimations() { | |
| animData = []; | |
| // fill in the keys | |
| recurseHierarchy( scene ); | |
| } | |
| function recurseHierarchy( node ) { | |
| var n = visualScene.getChildById( node.colladaId, true ), | |
| newData = null; | |
| if ( n && n.keys ) { | |
| newData = { | |
| fps: 60, | |
| hierarchy: [ { | |
| node: n, | |
| keys: n.keys, | |
| sids: n.sids | |
| } ], | |
| node: node, | |
| name: 'animation_' + node.name, | |
| length: 0 | |
| }; | |
| animData.push(newData); | |
| for ( var i = 0, il = n.keys.length; i < il; i ++ ) { | |
| newData.length = Math.max( newData.length, n.keys[i].time ); | |
| } | |
| } else { | |
| newData = { | |
| hierarchy: [ { | |
| keys: [], | |
| sids: [] | |
| } ] | |
| } | |
| } | |
| for ( var i = 0, il = node.children.length; i < il; i ++ ) { | |
| var d = recurseHierarchy( node.children[i] ); | |
| for ( var j = 0, jl = d.hierarchy.length; j < jl; j ++ ) { | |
| newData.hierarchy.push( { | |
| keys: [], | |
| sids: [] | |
| } ); | |
| } | |
| } | |
| return newData; | |
| } | |
| function calcAnimationBounds () { | |
| var start = 1000000; | |
| var end = -start; | |
| var frames = 0; | |
| var ID; | |
| for ( var id in animations ) { | |
| var animation = animations[ id ]; | |
| ID = ID || animation.id; | |
| for ( var i = 0; i < animation.sampler.length; i ++ ) { | |
| var sampler = animation.sampler[ i ]; | |
| sampler.create(); | |
| start = Math.min( start, sampler.startTime ); | |
| end = Math.max( end, sampler.endTime ); | |
| frames = Math.max( frames, sampler.input.length ); | |
| } | |
| } | |
| return { start:start, end:end, frames:frames,ID:ID }; | |
| } | |
| function createMorph ( geometry, ctrl ) { | |
| var morphCtrl = ctrl instanceof InstanceController ? controllers[ ctrl.url ] : ctrl; | |
| if ( !morphCtrl || !morphCtrl.morph ) { | |
| console.log("could not find morph controller!"); | |
| return; | |
| } | |
| var morph = morphCtrl.morph; | |
| for ( var i = 0; i < morph.targets.length; i ++ ) { | |
| var target_id = morph.targets[ i ]; | |
| var daeGeometry = geometries[ target_id ]; | |
| if ( !daeGeometry.mesh || | |
| !daeGeometry.mesh.primitives || | |
| !daeGeometry.mesh.primitives.length ) { | |
| continue; | |
| } | |
| var target = daeGeometry.mesh.primitives[ 0 ].geometry; | |
| if ( target.vertices.length === geometry.vertices.length ) { | |
| geometry.morphTargets.push( { name: "target_1", vertices: target.vertices } ); | |
| } | |
| } | |
| geometry.morphTargets.push( { name: "target_Z", vertices: geometry.vertices } ); | |
| } | |
| function createSkin ( geometry, ctrl, applyBindShape ) { | |
| var skinCtrl = controllers[ ctrl.url ]; | |
| if ( !skinCtrl || !skinCtrl.skin ) { | |
| console.log( "could not find skin controller!" ); | |
| return; | |
| } | |
| if ( !ctrl.skeleton || !ctrl.skeleton.length ) { | |
| console.log( "could not find the skeleton for the skin!" ); | |
| return; | |
| } | |
| var skin = skinCtrl.skin; | |
| var skeleton = visualScene.getChildById( ctrl.skeleton[ 0 ] ); | |
| var hierarchy = []; | |
| applyBindShape = applyBindShape !== undefined ? applyBindShape : true; | |
| var bones = []; | |
| geometry.skinWeights = []; | |
| geometry.skinIndices = []; | |
| //createBones( geometry.bones, skin, hierarchy, skeleton, null, -1 ); | |
| //createWeights( skin, geometry.bones, geometry.skinIndices, geometry.skinWeights ); | |
| /* | |
| geometry.animation = { | |
| name: 'take_001', | |
| fps: 30, | |
| length: 2, | |
| JIT: true, | |
| hierarchy: hierarchy | |
| }; | |
| */ | |
| if ( applyBindShape ) { | |
| for ( var i = 0; i < geometry.vertices.length; i ++ ) { | |
| geometry.vertices[ i ].applyMatrix4( skin.bindShapeMatrix ); | |
| } | |
| } | |
| } | |
| function setupSkeleton ( node, bones, frame, parent ) { | |
| node.world = node.world || new THREE.Matrix4(); | |
| node.localworld = node.localworld || new THREE.Matrix4(); | |
| node.world.copy( node.matrix ); | |
| node.localworld.copy( node.matrix ); | |
| if ( node.channels && node.channels.length ) { | |
| var channel = node.channels[ 0 ]; | |
| var m = channel.sampler.output[ frame ]; | |
| if ( m instanceof THREE.Matrix4 ) { | |
| node.world.copy( m ); | |
| node.localworld.copy(m); | |
| if (frame === 0) | |
| node.matrix.copy(m); | |
| } | |
| } | |
| if ( parent ) { | |
| node.world.multiplyMatrices( parent, node.world ); | |
| } | |
| bones.push( node ); | |
| for ( var i = 0; i < node.nodes.length; i ++ ) { | |
| setupSkeleton( node.nodes[ i ], bones, frame, node.world ); | |
| } | |
| } | |
| function setupSkinningMatrices ( bones, skin ) { | |
| // FIXME: this is dumb... | |
| for ( var i = 0; i < bones.length; i ++ ) { | |
| var bone = bones[ i ]; | |
| var found = -1; | |
| if ( bone.type != 'JOINT' ) continue; | |
| for ( var j = 0; j < skin.joints.length; j ++ ) { | |
| if ( bone.sid === skin.joints[ j ] ) { | |
| found = j; | |
| break; | |
| } | |
| } | |
| if ( found >= 0 ) { | |
| var inv = skin.invBindMatrices[ found ]; | |
| bone.invBindMatrix = inv; | |
| bone.skinningMatrix = new THREE.Matrix4(); | |
| bone.skinningMatrix.multiplyMatrices(bone.world, inv); // (IBMi * JMi) | |
| bone.animatrix = new THREE.Matrix4(); | |
| bone.animatrix.copy(bone.localworld); | |
| bone.weights = []; | |
| for ( var j = 0; j < skin.weights.length; j ++ ) { | |
| for (var k = 0; k < skin.weights[ j ].length; k ++ ) { | |
| var w = skin.weights[ j ][ k ]; | |
| if ( w.joint === found ) { | |
| bone.weights.push( w ); | |
| } | |
| } | |
| } | |
| } else { | |
| console.warn( "ColladaLoader: Could not find joint '" + bone.sid + "'." ); | |
| bone.skinningMatrix = new THREE.Matrix4(); | |
| bone.weights = []; | |
| } | |
| } | |
| } | |
| //Walk the Collada tree and flatten the bones into a list, extract the position, quat and scale from the matrix | |
| function flattenSkeleton(skeleton) { | |
| var list = []; | |
| var walk = function(parentid, node, list) { | |
| var bone = {}; | |
| bone.name = node.sid; | |
| bone.parent = parentid; | |
| bone.matrix = node.matrix; | |
| var data = [ new THREE.Vector3(),new THREE.Quaternion(),new THREE.Vector3() ]; | |
| bone.matrix.decompose(data[0], data[1], data[2]); | |
| bone.pos = [ data[0].x,data[0].y,data[0].z ]; | |
| bone.scl = [ data[2].x,data[2].y,data[2].z ]; | |
| bone.rotq = [ data[1].x,data[1].y,data[1].z,data[1].w ]; | |
| list.push(bone); | |
| for (var i in node.nodes) { | |
| walk(node.sid, node.nodes[i], list); | |
| } | |
| }; | |
| walk(-1, skeleton, list); | |
| return list; | |
| } | |
| //Move the vertices into the pose that is proper for the start of the animation | |
| function skinToBindPose(geometry,skeleton,skinController) { | |
| var bones = []; | |
| setupSkeleton( skeleton, bones, -1 ); | |
| setupSkinningMatrices( bones, skinController.skin ); | |
| var v = new THREE.Vector3(); | |
| var skinned = []; | |
| for (var i = 0; i < geometry.vertices.length; i ++) { | |
| skinned.push(new THREE.Vector3()); | |
| } | |
| for ( i = 0; i < bones.length; i ++ ) { | |
| if ( bones[ i ].type != 'JOINT' ) continue; | |
| for ( var j = 0; j < bones[ i ].weights.length; j ++ ) { | |
| var w = bones[ i ].weights[ j ]; | |
| var vidx = w.index; | |
| var weight = w.weight; | |
| var o = geometry.vertices[vidx]; | |
| var s = skinned[vidx]; | |
| v.x = o.x; | |
| v.y = o.y; | |
| v.z = o.z; | |
| v.applyMatrix4( bones[i].skinningMatrix ); | |
| s.x += (v.x * weight); | |
| s.y += (v.y * weight); | |
| s.z += (v.z * weight); | |
| } | |
| } | |
| for (var i = 0; i < geometry.vertices.length; i ++) { | |
| geometry.vertices[i] = skinned[i]; | |
| } | |
| } | |
| function applySkin ( geometry, instanceCtrl, frame ) { | |
| var skinController = controllers[ instanceCtrl.url ]; | |
| frame = frame !== undefined ? frame : 40; | |
| if ( !skinController || !skinController.skin ) { | |
| console.log( 'ColladaLoader: Could not find skin controller.' ); | |
| return; | |
| } | |
| if ( !instanceCtrl.skeleton || !instanceCtrl.skeleton.length ) { | |
| console.log( 'ColladaLoader: Could not find the skeleton for the skin. ' ); | |
| return; | |
| } | |
| var animationBounds = calcAnimationBounds(); | |
| var skeleton = visualScene.getChildById( instanceCtrl.skeleton[0], true ) || visualScene.getChildBySid( instanceCtrl.skeleton[0], true ); | |
| //flatten the skeleton into a list of bones | |
| var bonelist = flattenSkeleton(skeleton); | |
| var joints = skinController.skin.joints; | |
| //sort that list so that the order reflects the order in the joint list | |
| var sortedbones = []; | |
| for (var i = 0; i < joints.length; i ++) { | |
| for (var j = 0; j < bonelist.length; j ++) { | |
| if (bonelist[j].name === joints[i]) { | |
| sortedbones[i] = bonelist[j]; | |
| } | |
| } | |
| } | |
| //hook up the parents by index instead of name | |
| for (var i = 0; i < sortedbones.length; i ++) { | |
| for (var j = 0; j < sortedbones.length; j ++) { | |
| if (sortedbones[i].parent === sortedbones[j].name) { | |
| sortedbones[i].parent = j; | |
| } | |
| } | |
| } | |
| var i, j, w, vidx, weight; | |
| var v = new THREE.Vector3(), o, s; | |
| // move vertices to bind shape | |
| for ( i = 0; i < geometry.vertices.length; i ++ ) { | |
| geometry.vertices[i].applyMatrix4( skinController.skin.bindShapeMatrix ); | |
| } | |
| var skinIndices = []; | |
| var skinWeights = []; | |
| var weights = skinController.skin.weights; | |
| // hook up the skin weights | |
| // TODO - this might be a good place to choose greatest 4 weights | |
| for ( var i =0; i < weights.length; i ++ ) { | |
| var indicies = new THREE.Vector4(weights[i][0] ? weights[i][0].joint : 0,weights[i][1] ? weights[i][1].joint : 0,weights[i][2] ? weights[i][2].joint : 0,weights[i][3] ? weights[i][3].joint : 0); | |
| var weight = new THREE.Vector4(weights[i][0] ? weights[i][0].weight : 0,weights[i][1] ? weights[i][1].weight : 0,weights[i][2] ? weights[i][2].weight : 0,weights[i][3] ? weights[i][3].weight : 0); | |
| skinIndices.push(indicies); | |
| skinWeights.push(weight); | |
| } | |
| geometry.skinIndices = skinIndices; | |
| geometry.skinWeights = skinWeights; | |
| geometry.bones = sortedbones; | |
| // process animation, or simply pose the rig if no animation | |
| //create an animation for the animated bones | |
| //NOTE: this has no effect when using morphtargets | |
| var animationdata = { "name":animationBounds.ID,"fps":30,"length":animationBounds.frames / 30,"hierarchy":[] }; | |
| for (var j = 0; j < sortedbones.length; j ++) { | |
| animationdata.hierarchy.push({ parent:sortedbones[j].parent, name:sortedbones[j].name, keys:[] }); | |
| } | |
| console.log( 'ColladaLoader:', animationBounds.ID + ' has ' + sortedbones.length + ' bones.' ); | |
| skinToBindPose(geometry, skeleton, skinController); | |
| for ( frame = 0; frame < animationBounds.frames; frame ++ ) { | |
| var bones = []; | |
| var skinned = []; | |
| // process the frame and setup the rig with a fresh | |
| // transform, possibly from the bone's animation channel(s) | |
| setupSkeleton( skeleton, bones, frame ); | |
| setupSkinningMatrices( bones, skinController.skin ); | |
| for (var i = 0; i < bones.length; i ++) { | |
| for (var j = 0; j < animationdata.hierarchy.length; j ++) { | |
| if (animationdata.hierarchy[j].name === bones[i].sid) { | |
| var key = {}; | |
| key.time = (frame / 30); | |
| key.matrix = bones[i].animatrix; | |
| if (frame === 0) | |
| bones[i].matrix = key.matrix; | |
| var data = [ new THREE.Vector3(),new THREE.Quaternion(),new THREE.Vector3() ]; | |
| key.matrix.decompose(data[0], data[1], data[2]); | |
| key.pos = [ data[0].x,data[0].y,data[0].z ]; | |
| key.scl = [ data[2].x,data[2].y,data[2].z ]; | |
| key.rot = data[1]; | |
| animationdata.hierarchy[j].keys.push(key); | |
| } | |
| } | |
| } | |
| geometry.animation = animationdata; | |
| } | |
| } | |
| function createKinematics() { | |
| if ( kinematicsModel && kinematicsModel.joints.length === 0 ) { | |
| kinematics = undefined; | |
| return; | |
| } | |
| var jointMap = {}; | |
| var _addToMap = function( jointIndex, parentVisualElement ) { | |
| var parentVisualElementId = parentVisualElement.getAttribute( 'id' ); | |
| var colladaNode = visualScene.getChildById( parentVisualElementId, true ); | |
| var joint = kinematicsModel.joints[ jointIndex ]; | |
| scene.traverse(function( node ) { | |
| if ( node.colladaId == parentVisualElementId ) { | |
| jointMap[ jointIndex ] = { | |
| node: node, | |
| transforms: colladaNode.transforms, | |
| joint: joint, | |
| position: joint.zeroPosition | |
| }; | |
| } | |
| }); | |
| }; | |
| kinematics = { | |
| joints: kinematicsModel && kinematicsModel.joints, | |
| getJointValue: function( jointIndex ) { | |
| var jointData = jointMap[ jointIndex ]; | |
| if ( jointData ) { | |
| return jointData.position; | |
| } else { | |
| console.log( 'getJointValue: joint ' + jointIndex + ' doesn\'t exist' ); | |
| } | |
| }, | |
| setJointValue: function( jointIndex, value ) { | |
| var jointData = jointMap[ jointIndex ]; | |
| if ( jointData ) { | |
| var joint = jointData.joint; | |
| if ( value > joint.limits.max || value < joint.limits.min ) { | |
| console.log( 'setJointValue: joint ' + jointIndex + ' value ' + value + ' outside of limits (min: ' + joint.limits.min + ', max: ' + joint.limits.max + ')' ); | |
| } else if ( joint.static ) { | |
| console.log( 'setJointValue: joint ' + jointIndex + ' is static' ); | |
| } else { | |
| var threejsNode = jointData.node; | |
| var axis = joint.axis; | |
| var transforms = jointData.transforms; | |
| var matrix = new THREE.Matrix4(); | |
| for (i = 0; i < transforms.length; i ++ ) { | |
| var transform = transforms[ i ]; | |
| // kinda ghetto joint detection | |
| if ( transform.sid && transform.sid.indexOf( 'joint' + jointIndex ) !== -1 ) { | |
| // apply actual joint value here | |
| switch ( joint.type ) { | |
| case 'revolute': | |
| matrix.multiply( m1.makeRotationAxis( axis, THREE.Math.degToRad(value) ) ); | |
| break; | |
| case 'prismatic': | |
| matrix.multiply( m1.makeTranslation(axis.x * value, axis.y * value, axis.z * value ) ); | |
| break; | |
| default: | |
| console.warn( 'setJointValue: unknown joint type: ' + joint.type ); | |
| break; | |
| } | |
| } else { | |
| var m1 = new THREE.Matrix4(); | |
| switch ( transform.type ) { | |
| case 'matrix': | |
| matrix.multiply( transform.obj ); | |
| break; | |
| case 'translate': | |
| matrix.multiply( m1.makeTranslation( transform.obj.x, transform.obj.y, transform.obj.z ) ); | |
| break; | |
| case 'rotate': | |
| matrix.multiply( m1.makeRotationAxis( transform.obj, transform.angle ) ); | |
| break; | |
| } | |
| } | |
| } | |
| // apply the matrix to the threejs node | |
| var elementsFloat32Arr = matrix.elements; | |
| var elements = Array.prototype.slice.call( elementsFloat32Arr ); | |
| var elementsRowMajor = [ | |
| elements[ 0 ], | |
| elements[ 4 ], | |
| elements[ 8 ], | |
| elements[ 12 ], | |
| elements[ 1 ], | |
| elements[ 5 ], | |
| elements[ 9 ], | |
| elements[ 13 ], | |
| elements[ 2 ], | |
| elements[ 6 ], | |
| elements[ 10 ], | |
| elements[ 14 ], | |
| elements[ 3 ], | |
| elements[ 7 ], | |
| elements[ 11 ], | |
| elements[ 15 ] | |
| ]; | |
| threejsNode.matrix.set.apply( threejsNode.matrix, elementsRowMajor ); | |
| threejsNode.matrix.decompose( threejsNode.position, threejsNode.quaternion, threejsNode.scale ); | |
| } | |
| } else { | |
| console.log( 'setJointValue: joint ' + jointIndex + ' doesn\'t exist' ); | |
| } | |
| } | |
| }; | |
| var element = COLLADA.querySelector('scene instance_kinematics_scene'); | |
| if ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'bind_joint_axis': | |
| var visualTarget = child.getAttribute( 'target' ).split( '/' ).pop(); | |
| var axis = child.querySelector('axis param').textContent; | |
| var jointIndex = parseInt( axis.split( 'joint' ).pop().split( '.' )[0] ); | |
| var visualTargetElement = COLLADA.querySelector( '[sid="' + visualTarget + '"]' ); | |
| if ( visualTargetElement ) { | |
| var parentVisualElement = visualTargetElement.parentElement; | |
| _addToMap(jointIndex, parentVisualElement); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| function createSceneGraph ( node, parent ) { | |
| var obj = new THREE.Object3D(); | |
| var skinned = false; | |
| var skinController; | |
| var morphController; | |
| var i, j; | |
| // FIXME: controllers | |
| for ( i = 0; i < node.controllers.length; i ++ ) { | |
| var controller = controllers[ node.controllers[ i ].url ]; | |
| switch ( controller.type ) { | |
| case 'skin': | |
| if ( geometries[ controller.skin.source ] ) { | |
| var inst_geom = new InstanceGeometry(); | |
| inst_geom.url = controller.skin.source; | |
| inst_geom.instance_material = node.controllers[ i ].instance_material; | |
| node.geometries.push( inst_geom ); | |
| skinned = true; | |
| skinController = node.controllers[ i ]; | |
| } else if ( controllers[ controller.skin.source ] ) { | |
| // urgh: controller can be chained | |
| // handle the most basic case... | |
| var second = controllers[ controller.skin.source ]; | |
| morphController = second; | |
| // skinController = node.controllers[i]; | |
| if ( second.morph && geometries[ second.morph.source ] ) { | |
| var inst_geom = new InstanceGeometry(); | |
| inst_geom.url = second.morph.source; | |
| inst_geom.instance_material = node.controllers[ i ].instance_material; | |
| node.geometries.push( inst_geom ); | |
| } | |
| } | |
| break; | |
| case 'morph': | |
| if ( geometries[ controller.morph.source ] ) { | |
| var inst_geom = new InstanceGeometry(); | |
| inst_geom.url = controller.morph.source; | |
| inst_geom.instance_material = node.controllers[ i ].instance_material; | |
| node.geometries.push( inst_geom ); | |
| morphController = node.controllers[ i ]; | |
| } | |
| console.log( 'ColladaLoader: Morph-controller partially supported.' ); | |
| default: | |
| break; | |
| } | |
| } | |
| // geometries | |
| var double_sided_materials = {}; | |
| for ( i = 0; i < node.geometries.length; i ++ ) { | |
| var instance_geometry = node.geometries[i]; | |
| var instance_materials = instance_geometry.instance_material; | |
| var geometry = geometries[ instance_geometry.url ]; | |
| var used_materials = {}; | |
| var used_materials_array = []; | |
| var num_materials = 0; | |
| var first_material; | |
| if ( geometry ) { | |
| if ( !geometry.mesh || !geometry.mesh.primitives ) | |
| continue; | |
| if ( obj.name.length === 0 ) { | |
| obj.name = geometry.id; | |
| } | |
| // collect used fx for this geometry-instance | |
| if ( instance_materials ) { | |
| for ( j = 0; j < instance_materials.length; j ++ ) { | |
| var instance_material = instance_materials[ j ]; | |
| var mat = materials[ instance_material.target ]; | |
| var effect_id = mat.instance_effect.url; | |
| var shader = effects[ effect_id ].shader; | |
| var material3js = shader.material; | |
| if ( geometry.doubleSided ) { | |
| if ( !( instance_material.symbol in double_sided_materials ) ) { | |
| var _copied_material = material3js.clone(); | |
| _copied_material.side = THREE.DoubleSide; | |
| double_sided_materials[ instance_material.symbol ] = _copied_material; | |
| } | |
| material3js = double_sided_materials[ instance_material.symbol ]; | |
| } | |
| material3js.opacity = !material3js.opacity ? 1 : material3js.opacity; | |
| used_materials[ instance_material.symbol ] = num_materials; | |
| used_materials_array.push( material3js ); | |
| first_material = material3js; | |
| first_material.name = mat.name === null || mat.name === '' ? mat.id : mat.name; | |
| num_materials ++; | |
| } | |
| } | |
| var mesh; | |
| var material = first_material || new THREE.MeshLambertMaterial( { color: 0xdddddd, side: geometry.doubleSided ? THREE.DoubleSide : THREE.FrontSide } ); | |
| var geom = geometry.mesh.geometry3js; | |
| if ( num_materials > 1 ) { | |
| material = new THREE.MultiMaterial( used_materials_array ); | |
| } | |
| if ( skinController !== undefined ) { | |
| applySkin( geom, skinController ); | |
| if ( geom.morphTargets.length > 0 ) { | |
| material.morphTargets = true; | |
| material.skinning = false; | |
| } else { | |
| material.morphTargets = false; | |
| material.skinning = true; | |
| } | |
| mesh = new THREE.SkinnedMesh( geom, material, false ); | |
| //mesh.skeleton = skinController.skeleton; | |
| //mesh.skinController = controllers[ skinController.url ]; | |
| //mesh.skinInstanceController = skinController; | |
| mesh.name = 'skin_' + skins.length; | |
| //mesh.animationHandle.setKey(0); | |
| skins.push( mesh ); | |
| } else if ( morphController !== undefined ) { | |
| createMorph( geom, morphController ); | |
| material.morphTargets = true; | |
| mesh = new THREE.Mesh( geom, material ); | |
| mesh.name = 'morph_' + morphs.length; | |
| morphs.push( mesh ); | |
| } else { | |
| if ( geom.isLineStrip === true ) { | |
| mesh = new THREE.Line( geom ); | |
| } else { | |
| mesh = new THREE.Mesh( geom, material ); | |
| } | |
| } | |
| obj.add(mesh); | |
| } | |
| } | |
| for ( i = 0; i < node.cameras.length; i ++ ) { | |
| var instance_camera = node.cameras[i]; | |
| var cparams = cameras[instance_camera.url]; | |
| var cam = new THREE.PerspectiveCamera(cparams.yfov, parseFloat(cparams.aspect_ratio), | |
| parseFloat(cparams.znear), parseFloat(cparams.zfar)); | |
| obj.add(cam); | |
| } | |
| for ( i = 0; i < node.lights.length; i ++ ) { | |
| var light = null; | |
| var instance_light = node.lights[i]; | |
| var lparams = lights[instance_light.url]; | |
| if ( lparams && lparams.technique ) { | |
| var color = lparams.color.getHex(); | |
| var intensity = lparams.intensity; | |
| var distance = lparams.distance; | |
| var angle = lparams.falloff_angle; | |
| var exponent; // Intentionally undefined, don't know what this is yet | |
| switch ( lparams.technique ) { | |
| case 'directional': | |
| light = new THREE.DirectionalLight( color, intensity, distance ); | |
| light.position.set(0, 0, 1); | |
| break; | |
| case 'point': | |
| light = new THREE.PointLight( color, intensity, distance ); | |
| break; | |
| case 'spot': | |
| light = new THREE.SpotLight( color, intensity, distance, angle, exponent ); | |
| light.position.set(0, 0, 1); | |
| break; | |
| case 'ambient': | |
| light = new THREE.AmbientLight( color ); | |
| break; | |
| } | |
| } | |
| if (light) { | |
| obj.add(light); | |
| } | |
| } | |
| obj.name = node.name || node.id || ""; | |
| obj.colladaId = node.id || ""; | |
| obj.layer = node.layer || ""; | |
| obj.matrix = node.matrix; | |
| obj.matrix.decompose( obj.position, obj.quaternion, obj.scale ); | |
| if ( options.centerGeometry && obj.geometry ) { | |
| var delta = obj.geometry.center(); | |
| delta.multiply( obj.scale ); | |
| delta.applyQuaternion( obj.quaternion ); | |
| obj.position.sub( delta ); | |
| } | |
| for ( i = 0; i < node.nodes.length; i ++ ) { | |
| obj.add( createSceneGraph( node.nodes[i], node ) ); | |
| } | |
| return obj; | |
| } | |
| function getJointId( skin, id ) { | |
| for ( var i = 0; i < skin.joints.length; i ++ ) { | |
| if ( skin.joints[ i ] === id ) { | |
| return i; | |
| } | |
| } | |
| } | |
| function getLibraryNode( id ) { | |
| var nodes = COLLADA.querySelectorAll('library_nodes node'); | |
| for ( var i = 0; i < nodes.length; i++ ) { | |
| var attObj = nodes[i].attributes.getNamedItem('id'); | |
| if ( attObj && attObj.value === id ) { | |
| return nodes[i]; | |
| } | |
| } | |
| return undefined; | |
| } | |
| function getChannelsForNode ( node ) { | |
| var channels = []; | |
| var startTime = 1000000; | |
| var endTime = -1000000; | |
| for ( var id in animations ) { | |
| var animation = animations[id]; | |
| for ( var i = 0; i < animation.channel.length; i ++ ) { | |
| var channel = animation.channel[i]; | |
| var sampler = animation.sampler[i]; | |
| var id = channel.target.split('/')[0]; | |
| if ( id == node.id ) { | |
| sampler.create(); | |
| channel.sampler = sampler; | |
| startTime = Math.min(startTime, sampler.startTime); | |
| endTime = Math.max(endTime, sampler.endTime); | |
| channels.push(channel); | |
| } | |
| } | |
| } | |
| if ( channels.length ) { | |
| node.startTime = startTime; | |
| node.endTime = endTime; | |
| } | |
| return channels; | |
| } | |
| function calcFrameDuration( node ) { | |
| var minT = 10000000; | |
| for ( var i = 0; i < node.channels.length; i ++ ) { | |
| var sampler = node.channels[i].sampler; | |
| for ( var j = 0; j < sampler.input.length - 1; j ++ ) { | |
| var t0 = sampler.input[ j ]; | |
| var t1 = sampler.input[ j + 1 ]; | |
| minT = Math.min( minT, t1 - t0 ); | |
| } | |
| } | |
| return minT; | |
| } | |
| function calcMatrixAt( node, t ) { | |
| var animated = {}; | |
| var i, j; | |
| for ( i = 0; i < node.channels.length; i ++ ) { | |
| var channel = node.channels[ i ]; | |
| animated[ channel.sid ] = channel; | |
| } | |
| var matrix = new THREE.Matrix4(); | |
| for ( i = 0; i < node.transforms.length; i ++ ) { | |
| var transform = node.transforms[ i ]; | |
| var channel = animated[ transform.sid ]; | |
| if ( channel !== undefined ) { | |
| var sampler = channel.sampler; | |
| var value; | |
| for ( j = 0; j < sampler.input.length - 1; j ++ ) { | |
| if ( sampler.input[ j + 1 ] > t ) { | |
| value = sampler.output[ j ]; | |
| //console.log(value.flatten) | |
| break; | |
| } | |
| } | |
| if ( value !== undefined ) { | |
| if ( value instanceof THREE.Matrix4 ) { | |
| matrix.multiplyMatrices( matrix, value ); | |
| } else { | |
| // FIXME: handle other types | |
| matrix.multiplyMatrices( matrix, transform.matrix ); | |
| } | |
| } else { | |
| matrix.multiplyMatrices( matrix, transform.matrix ); | |
| } | |
| } else { | |
| matrix.multiplyMatrices( matrix, transform.matrix ); | |
| } | |
| } | |
| return matrix; | |
| } | |
| function bakeAnimations ( node ) { | |
| if ( node.channels && node.channels.length ) { | |
| var keys = [], | |
| sids = []; | |
| for ( var i = 0, il = node.channels.length; i < il; i ++ ) { | |
| var channel = node.channels[i], | |
| fullSid = channel.fullSid, | |
| sampler = channel.sampler, | |
| input = sampler.input, | |
| transform = node.getTransformBySid( channel.sid ), | |
| member; | |
| if ( channel.arrIndices ) { | |
| member = []; | |
| for ( var j = 0, jl = channel.arrIndices.length; j < jl; j ++ ) { | |
| member[ j ] = getConvertedIndex( channel.arrIndices[ j ] ); | |
| } | |
| } else { | |
| member = getConvertedMember( channel.member ); | |
| } | |
| if ( transform ) { | |
| if ( sids.indexOf( fullSid ) === -1 ) { | |
| sids.push( fullSid ); | |
| } | |
| for ( var j = 0, jl = input.length; j < jl; j ++ ) { | |
| var time = input[j], | |
| data = sampler.getData( transform.type, j, member ), | |
| key = findKey( keys, time ); | |
| if ( !key ) { | |
| key = new Key( time ); | |
| var timeNdx = findTimeNdx( keys, time ); | |
| keys.splice( timeNdx === -1 ? keys.length : timeNdx, 0, key ); | |
| } | |
| key.addTarget( fullSid, transform, member, data ); | |
| } | |
| } else { | |
| console.log( 'Could not find transform "' + channel.sid + '" in node ' + node.id ); | |
| } | |
| } | |
| // post process | |
| for ( var i = 0; i < sids.length; i ++ ) { | |
| var sid = sids[ i ]; | |
| for ( var j = 0; j < keys.length; j ++ ) { | |
| var key = keys[ j ]; | |
| if ( !key.hasTarget( sid ) ) { | |
| interpolateKeys( keys, key, j, sid ); | |
| } | |
| } | |
| } | |
| node.keys = keys; | |
| node.sids = sids; | |
| } | |
| } | |
| function findKey ( keys, time) { | |
| var retVal = null; | |
| for ( var i = 0, il = keys.length; i < il && retVal === null; i ++ ) { | |
| var key = keys[i]; | |
| if ( key.time === time ) { | |
| retVal = key; | |
| } else if ( key.time > time ) { | |
| break; | |
| } | |
| } | |
| return retVal; | |
| } | |
| function findTimeNdx ( keys, time) { | |
| var ndx = -1; | |
| for ( var i = 0, il = keys.length; i < il && ndx === -1; i ++ ) { | |
| var key = keys[i]; | |
| if ( key.time >= time ) { | |
| ndx = i; | |
| } | |
| } | |
| return ndx; | |
| } | |
| function interpolateKeys ( keys, key, ndx, fullSid ) { | |
| var prevKey = getPrevKeyWith( keys, fullSid, ndx ? ndx - 1 : 0 ), | |
| nextKey = getNextKeyWith( keys, fullSid, ndx + 1 ); | |
| if ( prevKey && nextKey ) { | |
| var scale = (key.time - prevKey.time) / (nextKey.time - prevKey.time), | |
| prevTarget = prevKey.getTarget( fullSid ), | |
| nextData = nextKey.getTarget( fullSid ).data, | |
| prevData = prevTarget.data, | |
| data; | |
| if ( prevTarget.type === 'matrix' ) { | |
| data = prevData; | |
| } else if ( prevData.length ) { | |
| data = []; | |
| for ( var i = 0; i < prevData.length; ++ i ) { | |
| data[ i ] = prevData[ i ] + ( nextData[ i ] - prevData[ i ] ) * scale; | |
| } | |
| } else { | |
| data = prevData + ( nextData - prevData ) * scale; | |
| } | |
| key.addTarget( fullSid, prevTarget.transform, prevTarget.member, data ); | |
| } | |
| } | |
| // Get next key with given sid | |
| function getNextKeyWith( keys, fullSid, ndx ) { | |
| for ( ; ndx < keys.length; ndx ++ ) { | |
| var key = keys[ ndx ]; | |
| if ( key.hasTarget( fullSid ) ) { | |
| return key; | |
| } | |
| } | |
| return null; | |
| } | |
| // Get previous key with given sid | |
| function getPrevKeyWith( keys, fullSid, ndx ) { | |
| ndx = ndx >= 0 ? ndx : ndx + keys.length; | |
| for ( ; ndx >= 0; ndx -- ) { | |
| var key = keys[ ndx ]; | |
| if ( key.hasTarget( fullSid ) ) { | |
| return key; | |
| } | |
| } | |
| return null; | |
| } | |
| function _Image() { | |
| this.id = ""; | |
| this.init_from = ""; | |
| } | |
| _Image.prototype.parse = function(element) { | |
| this.id = element.getAttribute('id'); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeName === 'init_from' ) { | |
| this.init_from = child.textContent; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Controller() { | |
| this.id = ""; | |
| this.name = ""; | |
| this.type = ""; | |
| this.skin = null; | |
| this.morph = null; | |
| } | |
| Controller.prototype.parse = function( element ) { | |
| this.id = element.getAttribute('id'); | |
| this.name = element.getAttribute('name'); | |
| this.type = "none"; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| switch ( child.nodeName ) { | |
| case 'skin': | |
| this.skin = (new Skin()).parse(child); | |
| this.type = child.nodeName; | |
| break; | |
| case 'morph': | |
| this.morph = (new Morph()).parse(child); | |
| this.type = child.nodeName; | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Morph() { | |
| this.method = null; | |
| this.source = null; | |
| this.targets = null; | |
| this.weights = null; | |
| } | |
| Morph.prototype.parse = function( element ) { | |
| var sources = {}; | |
| var inputs = []; | |
| var i; | |
| this.method = element.getAttribute( 'method' ); | |
| this.source = element.getAttribute( 'source' ).replace( /^#/, '' ); | |
| for ( i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'source': | |
| var source = ( new Source() ).parse( child ); | |
| sources[ source.id ] = source; | |
| break; | |
| case 'targets': | |
| inputs = this.parseInputs( child ); | |
| break; | |
| default: | |
| console.log( child.nodeName ); | |
| break; | |
| } | |
| } | |
| for ( i = 0; i < inputs.length; i ++ ) { | |
| var input = inputs[ i ]; | |
| var source = sources[ input.source ]; | |
| switch ( input.semantic ) { | |
| case 'MORPH_TARGET': | |
| this.targets = source.read(); | |
| break; | |
| case 'MORPH_WEIGHT': | |
| this.weights = source.read(); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| Morph.prototype.parseInputs = function(element) { | |
| var inputs = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| if ( child.nodeType != 1) continue; | |
| switch ( child.nodeName ) { | |
| case 'input': | |
| inputs.push( (new Input()).parse(child) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return inputs; | |
| }; | |
| function Skin() { | |
| this.source = ""; | |
| this.bindShapeMatrix = null; | |
| this.invBindMatrices = []; | |
| this.joints = []; | |
| this.weights = []; | |
| } | |
| Skin.prototype.parse = function( element ) { | |
| var sources = {}; | |
| var joints, weights; | |
| this.source = element.getAttribute( 'source' ).replace( /^#/, '' ); | |
| this.invBindMatrices = []; | |
| this.joints = []; | |
| this.weights = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'bind_shape_matrix': | |
| var f = _floats(child.textContent); | |
| this.bindShapeMatrix = getConvertedMat4( f ); | |
| break; | |
| case 'source': | |
| var src = new Source().parse(child); | |
| sources[ src.id ] = src; | |
| break; | |
| case 'joints': | |
| joints = child; | |
| break; | |
| case 'vertex_weights': | |
| weights = child; | |
| break; | |
| default: | |
| console.log( child.nodeName ); | |
| break; | |
| } | |
| } | |
| this.parseJoints( joints, sources ); | |
| this.parseWeights( weights, sources ); | |
| return this; | |
| }; | |
| Skin.prototype.parseJoints = function ( element, sources ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'input': | |
| var input = ( new Input() ).parse( child ); | |
| var source = sources[ input.source ]; | |
| if ( input.semantic === 'JOINT' ) { | |
| this.joints = source.read(); | |
| } else if ( input.semantic === 'INV_BIND_MATRIX' ) { | |
| this.invBindMatrices = source.read(); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| }; | |
| Skin.prototype.parseWeights = function ( element, sources ) { | |
| var v, vcount, inputs = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'input': | |
| inputs.push( ( new Input() ).parse( child ) ); | |
| break; | |
| case 'v': | |
| v = _ints( child.textContent ); | |
| break; | |
| case 'vcount': | |
| vcount = _ints( child.textContent ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| var index = 0; | |
| for ( var i = 0; i < vcount.length; i ++ ) { | |
| var numBones = vcount[i]; | |
| var vertex_weights = []; | |
| for ( var j = 0; j < numBones; j ++ ) { | |
| var influence = {}; | |
| for ( var k = 0; k < inputs.length; k ++ ) { | |
| var input = inputs[ k ]; | |
| var value = v[ index + input.offset ]; | |
| switch ( input.semantic ) { | |
| case 'JOINT': | |
| influence.joint = value;//this.joints[value]; | |
| break; | |
| case 'WEIGHT': | |
| influence.weight = sources[ input.source ].data[ value ]; | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| vertex_weights.push( influence ); | |
| index += inputs.length; | |
| } | |
| for ( var j = 0; j < vertex_weights.length; j ++ ) { | |
| vertex_weights[ j ].index = i; | |
| } | |
| this.weights.push( vertex_weights ); | |
| } | |
| }; | |
| function VisualScene () { | |
| this.id = ""; | |
| this.name = ""; | |
| this.nodes = []; | |
| this.scene = new THREE.Group(); | |
| } | |
| VisualScene.prototype.getChildById = function( id, recursive ) { | |
| for ( var i = 0; i < this.nodes.length; i ++ ) { | |
| var node = this.nodes[ i ].getChildById( id, recursive ); | |
| if ( node ) { | |
| return node; | |
| } | |
| } | |
| return null; | |
| }; | |
| VisualScene.prototype.getChildBySid = function( sid, recursive ) { | |
| for ( var i = 0; i < this.nodes.length; i ++ ) { | |
| var node = this.nodes[ i ].getChildBySid( sid, recursive ); | |
| if ( node ) { | |
| return node; | |
| } | |
| } | |
| return null; | |
| }; | |
| VisualScene.prototype.parse = function( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| this.name = element.getAttribute( 'name' ); | |
| this.nodes = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'node': | |
| this.nodes.push( ( new Node() ).parse( child ) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Node() { | |
| this.id = ""; | |
| this.name = ""; | |
| this.sid = ""; | |
| this.nodes = []; | |
| this.controllers = []; | |
| this.transforms = []; | |
| this.geometries = []; | |
| this.channels = []; | |
| this.matrix = new THREE.Matrix4(); | |
| } | |
| Node.prototype.getChannelForTransform = function( transformSid ) { | |
| for ( var i = 0; i < this.channels.length; i ++ ) { | |
| var channel = this.channels[i]; | |
| var parts = channel.target.split('/'); | |
| var id = parts.shift(); | |
| var sid = parts.shift(); | |
| var dotSyntax = (sid.indexOf(".") >= 0); | |
| var arrSyntax = (sid.indexOf("(") >= 0); | |
| var arrIndices; | |
| var member; | |
| if ( dotSyntax ) { | |
| parts = sid.split("."); | |
| sid = parts.shift(); | |
| member = parts.shift(); | |
| } else if ( arrSyntax ) { | |
| arrIndices = sid.split("("); | |
| sid = arrIndices.shift(); | |
| for ( var j = 0; j < arrIndices.length; j ++ ) { | |
| arrIndices[ j ] = parseInt( arrIndices[ j ].replace( /\)/, '' ) ); | |
| } | |
| } | |
| if ( sid === transformSid ) { | |
| channel.info = { sid: sid, dotSyntax: dotSyntax, arrSyntax: arrSyntax, arrIndices: arrIndices }; | |
| return channel; | |
| } | |
| } | |
| return null; | |
| }; | |
| Node.prototype.getChildById = function ( id, recursive ) { | |
| if ( this.id === id ) { | |
| return this; | |
| } | |
| if ( recursive ) { | |
| for ( var i = 0; i < this.nodes.length; i ++ ) { | |
| var n = this.nodes[ i ].getChildById( id, recursive ); | |
| if ( n ) { | |
| return n; | |
| } | |
| } | |
| } | |
| return null; | |
| }; | |
| Node.prototype.getChildBySid = function ( sid, recursive ) { | |
| if ( this.sid === sid ) { | |
| return this; | |
| } | |
| if ( recursive ) { | |
| for ( var i = 0; i < this.nodes.length; i ++ ) { | |
| var n = this.nodes[ i ].getChildBySid( sid, recursive ); | |
| if ( n ) { | |
| return n; | |
| } | |
| } | |
| } | |
| return null; | |
| }; | |
| Node.prototype.getTransformBySid = function ( sid ) { | |
| for ( var i = 0; i < this.transforms.length; i ++ ) { | |
| if ( this.transforms[ i ].sid === sid ) return this.transforms[ i ]; | |
| } | |
| return null; | |
| }; | |
| Node.prototype.parse = function( element ) { | |
| var url; | |
| this.id = element.getAttribute('id'); | |
| this.sid = element.getAttribute('sid'); | |
| this.name = element.getAttribute('name'); | |
| this.type = element.getAttribute('type'); | |
| this.layer = element.getAttribute('layer'); | |
| this.type = this.type === 'JOINT' ? this.type : 'NODE'; | |
| this.nodes = []; | |
| this.transforms = []; | |
| this.geometries = []; | |
| this.cameras = []; | |
| this.lights = []; | |
| this.controllers = []; | |
| this.matrix = new THREE.Matrix4(); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'node': | |
| this.nodes.push( ( new Node() ).parse( child ) ); | |
| break; | |
| case 'instance_camera': | |
| this.cameras.push( ( new InstanceCamera() ).parse( child ) ); | |
| break; | |
| case 'instance_controller': | |
| this.controllers.push( ( new InstanceController() ).parse( child ) ); | |
| break; | |
| case 'instance_geometry': | |
| this.geometries.push( ( new InstanceGeometry() ).parse( child ) ); | |
| break; | |
| case 'instance_light': | |
| this.lights.push( ( new InstanceLight() ).parse( child ) ); | |
| break; | |
| case 'instance_node': | |
| url = child.getAttribute( 'url' ).replace( /^#/, '' ); | |
| var iNode = getLibraryNode( url ); | |
| if ( iNode ) { | |
| this.nodes.push( ( new Node() ).parse( iNode )) ; | |
| } | |
| break; | |
| case 'rotate': | |
| case 'translate': | |
| case 'scale': | |
| case 'matrix': | |
| case 'lookat': | |
| case 'skew': | |
| this.transforms.push( ( new Transform() ).parse( child ) ); | |
| break; | |
| case 'extra': | |
| break; | |
| default: | |
| console.log( child.nodeName ); | |
| break; | |
| } | |
| } | |
| this.channels = getChannelsForNode( this ); | |
| bakeAnimations( this ); | |
| this.updateMatrix(); | |
| return this; | |
| }; | |
| Node.prototype.updateMatrix = function () { | |
| this.matrix.identity(); | |
| for ( var i = 0; i < this.transforms.length; i ++ ) { | |
| this.transforms[ i ].apply( this.matrix ); | |
| } | |
| }; | |
| function Transform () { | |
| this.sid = ""; | |
| this.type = ""; | |
| this.data = []; | |
| this.obj = null; | |
| } | |
| Transform.prototype.parse = function ( element ) { | |
| this.sid = element.getAttribute( 'sid' ); | |
| this.type = element.nodeName; | |
| this.data = _floats( element.textContent ); | |
| this.convert(); | |
| return this; | |
| }; | |
| Transform.prototype.convert = function () { | |
| switch ( this.type ) { | |
| case 'matrix': | |
| this.obj = getConvertedMat4( this.data ); | |
| break; | |
| case 'rotate': | |
| this.angle = THREE.Math.degToRad( this.data[3] ); | |
| case 'translate': | |
| fixCoords( this.data, -1 ); | |
| this.obj = new THREE.Vector3( this.data[ 0 ], this.data[ 1 ], this.data[ 2 ] ); | |
| break; | |
| case 'scale': | |
| fixCoords( this.data, 1 ); | |
| this.obj = new THREE.Vector3( this.data[ 0 ], this.data[ 1 ], this.data[ 2 ] ); | |
| break; | |
| default: | |
| console.log( 'Can not convert Transform of type ' + this.type ); | |
| break; | |
| } | |
| }; | |
| Transform.prototype.apply = function () { | |
| var m1 = new THREE.Matrix4(); | |
| return function ( matrix ) { | |
| switch ( this.type ) { | |
| case 'matrix': | |
| matrix.multiply( this.obj ); | |
| break; | |
| case 'translate': | |
| matrix.multiply( m1.makeTranslation( this.obj.x, this.obj.y, this.obj.z ) ); | |
| break; | |
| case 'rotate': | |
| matrix.multiply( m1.makeRotationAxis( this.obj, this.angle ) ); | |
| break; | |
| case 'scale': | |
| matrix.scale( this.obj ); | |
| break; | |
| } | |
| }; | |
| }(); | |
| Transform.prototype.update = function ( data, member ) { | |
| var members = [ 'X', 'Y', 'Z', 'ANGLE' ]; | |
| switch ( this.type ) { | |
| case 'matrix': | |
| if ( ! member ) { | |
| this.obj.copy( data ); | |
| } else if ( member.length === 1 ) { | |
| switch ( member[ 0 ] ) { | |
| case 0: | |
| this.obj.n11 = data[ 0 ]; | |
| this.obj.n21 = data[ 1 ]; | |
| this.obj.n31 = data[ 2 ]; | |
| this.obj.n41 = data[ 3 ]; | |
| break; | |
| case 1: | |
| this.obj.n12 = data[ 0 ]; | |
| this.obj.n22 = data[ 1 ]; | |
| this.obj.n32 = data[ 2 ]; | |
| this.obj.n42 = data[ 3 ]; | |
| break; | |
| case 2: | |
| this.obj.n13 = data[ 0 ]; | |
| this.obj.n23 = data[ 1 ]; | |
| this.obj.n33 = data[ 2 ]; | |
| this.obj.n43 = data[ 3 ]; | |
| break; | |
| case 3: | |
| this.obj.n14 = data[ 0 ]; | |
| this.obj.n24 = data[ 1 ]; | |
| this.obj.n34 = data[ 2 ]; | |
| this.obj.n44 = data[ 3 ]; | |
| break; | |
| } | |
| } else if ( member.length === 2 ) { | |
| var propName = 'n' + ( member[ 0 ] + 1 ) + ( member[ 1 ] + 1 ); | |
| this.obj[ propName ] = data; | |
| } else { | |
| console.log('Incorrect addressing of matrix in transform.'); | |
| } | |
| break; | |
| case 'translate': | |
| case 'scale': | |
| if ( Object.prototype.toString.call( member ) === '[object Array]' ) { | |
| member = members[ member[ 0 ] ]; | |
| } | |
| switch ( member ) { | |
| case 'X': | |
| this.obj.x = data; | |
| break; | |
| case 'Y': | |
| this.obj.y = data; | |
| break; | |
| case 'Z': | |
| this.obj.z = data; | |
| break; | |
| default: | |
| this.obj.x = data[ 0 ]; | |
| this.obj.y = data[ 1 ]; | |
| this.obj.z = data[ 2 ]; | |
| break; | |
| } | |
| break; | |
| case 'rotate': | |
| if ( Object.prototype.toString.call( member ) === '[object Array]' ) { | |
| member = members[ member[ 0 ] ]; | |
| } | |
| switch ( member ) { | |
| case 'X': | |
| this.obj.x = data; | |
| break; | |
| case 'Y': | |
| this.obj.y = data; | |
| break; | |
| case 'Z': | |
| this.obj.z = data; | |
| break; | |
| case 'ANGLE': | |
| this.angle = THREE.Math.degToRad( data ); | |
| break; | |
| default: | |
| this.obj.x = data[ 0 ]; | |
| this.obj.y = data[ 1 ]; | |
| this.obj.z = data[ 2 ]; | |
| this.angle = THREE.Math.degToRad( data[ 3 ] ); | |
| break; | |
| } | |
| break; | |
| } | |
| }; | |
| function InstanceController() { | |
| this.url = ""; | |
| this.skeleton = []; | |
| this.instance_material = []; | |
| } | |
| InstanceController.prototype.parse = function ( element ) { | |
| this.url = element.getAttribute('url').replace(/^#/, ''); | |
| this.skeleton = []; | |
| this.instance_material = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType !== 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'skeleton': | |
| this.skeleton.push( child.textContent.replace(/^#/, '') ); | |
| break; | |
| case 'bind_material': | |
| var instances = child.querySelectorAll('instance_material'); | |
| for ( var j = 0; j < instances.length; j ++ ) { | |
| var instance = instances[j]; | |
| this.instance_material.push( (new InstanceMaterial()).parse(instance) ); | |
| } | |
| break; | |
| case 'extra': | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function InstanceMaterial () { | |
| this.symbol = ""; | |
| this.target = ""; | |
| } | |
| InstanceMaterial.prototype.parse = function ( element ) { | |
| this.symbol = element.getAttribute('symbol'); | |
| this.target = element.getAttribute('target').replace(/^#/, ''); | |
| return this; | |
| }; | |
| function InstanceGeometry() { | |
| this.url = ""; | |
| this.instance_material = []; | |
| } | |
| InstanceGeometry.prototype.parse = function ( element ) { | |
| this.url = element.getAttribute('url').replace(/^#/, ''); | |
| this.instance_material = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| if ( child.nodeType != 1 ) continue; | |
| if ( child.nodeName === 'bind_material' ) { | |
| var instances = child.querySelectorAll('instance_material'); | |
| for ( var j = 0; j < instances.length; j ++ ) { | |
| var instance = instances[j]; | |
| this.instance_material.push( (new InstanceMaterial()).parse(instance) ); | |
| } | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Geometry() { | |
| this.id = ""; | |
| this.mesh = null; | |
| } | |
| Geometry.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute('id'); | |
| extractDoubleSided( this, element ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| switch ( child.nodeName ) { | |
| case 'mesh': | |
| this.mesh = (new Mesh(this)).parse(child); | |
| break; | |
| case 'extra': | |
| // console.log( child ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Mesh( geometry ) { | |
| this.geometry = geometry.id; | |
| this.primitives = []; | |
| this.vertices = null; | |
| this.geometry3js = null; | |
| } | |
| Mesh.prototype.parse = function ( element ) { | |
| this.primitives = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| switch ( child.nodeName ) { | |
| case 'source': | |
| _source( child ); | |
| break; | |
| case 'vertices': | |
| this.vertices = ( new Vertices() ).parse( child ); | |
| break; | |
| case 'linestrips': | |
| this.primitives.push( ( new LineStrips().parse( child ) ) ); | |
| break; | |
| case 'triangles': | |
| this.primitives.push( ( new Triangles().parse( child ) ) ); | |
| break; | |
| case 'polygons': | |
| this.primitives.push( ( new Polygons().parse( child ) ) ); | |
| break; | |
| case 'polylist': | |
| this.primitives.push( ( new Polylist().parse( child ) ) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| this.geometry3js = new THREE.Geometry(); | |
| if ( this.vertices === null ) { | |
| // TODO (mrdoob): Study case when this is null (carrier.dae) | |
| return this; | |
| } | |
| var vertexData = sources[ this.vertices.input['POSITION'].source ].data; | |
| for ( var i = 0; i < vertexData.length; i += 3 ) { | |
| this.geometry3js.vertices.push( getConvertedVec3( vertexData, i ).clone() ); | |
| } | |
| for ( var i = 0; i < this.primitives.length; i ++ ) { | |
| var primitive = this.primitives[ i ]; | |
| primitive.setVertices( this.vertices ); | |
| this.handlePrimitive( primitive, this.geometry3js ); | |
| } | |
| if ( this.geometry3js.calcNormals ) { | |
| this.geometry3js.computeVertexNormals(); | |
| delete this.geometry3js.calcNormals; | |
| } | |
| return this; | |
| }; | |
| Mesh.prototype.handlePrimitive = function ( primitive, geom ) { | |
| if ( primitive instanceof LineStrips ) { | |
| // TODO: Handle indices. Maybe easier with BufferGeometry? | |
| geom.isLineStrip = true; | |
| return; | |
| } | |
| var j, k, pList = primitive.p, inputs = primitive.inputs; | |
| var input, index, idx32; | |
| var source, numParams; | |
| var vcIndex = 0, vcount = 3, maxOffset = 0; | |
| var texture_sets = []; | |
| for ( j = 0; j < inputs.length; j ++ ) { | |
| input = inputs[ j ]; | |
| var offset = input.offset + 1; | |
| maxOffset = (maxOffset < offset) ? offset : maxOffset; | |
| switch ( input.semantic ) { | |
| case 'TEXCOORD': | |
| texture_sets.push( input.set ); | |
| break; | |
| } | |
| } | |
| for ( var pCount = 0; pCount < pList.length; ++ pCount ) { | |
| var p = pList[ pCount ], i = 0; | |
| while ( i < p.length ) { | |
| var vs = []; | |
| var ns = []; | |
| var ts = null; | |
| var cs = []; | |
| if ( primitive.vcount ) { | |
| vcount = primitive.vcount.length ? primitive.vcount[ vcIndex ++ ] : primitive.vcount; | |
| } else { | |
| vcount = p.length / maxOffset; | |
| } | |
| for ( j = 0; j < vcount; j ++ ) { | |
| for ( k = 0; k < inputs.length; k ++ ) { | |
| input = inputs[ k ]; | |
| source = sources[ input.source ]; | |
| index = p[ i + ( j * maxOffset ) + input.offset ]; | |
| numParams = source.accessor.params.length; | |
| idx32 = index * numParams; | |
| switch ( input.semantic ) { | |
| case 'VERTEX': | |
| vs.push( index ); | |
| break; | |
| case 'NORMAL': | |
| ns.push( getConvertedVec3( source.data, idx32 ) ); | |
| break; | |
| case 'TEXCOORD': | |
| ts = ts || { }; | |
| if ( ts[ input.set ] === undefined ) ts[ input.set ] = []; | |
| // invert the V | |
| ts[ input.set ].push( new THREE.Vector2( source.data[ idx32 ], source.data[ idx32 + 1 ] ) ); | |
| break; | |
| case 'COLOR': | |
| cs.push( new THREE.Color().setRGB( source.data[ idx32 ], source.data[ idx32 + 1 ], source.data[ idx32 + 2 ] ) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| } | |
| if ( ns.length === 0 ) { | |
| // check the vertices inputs | |
| input = this.vertices.input.NORMAL; | |
| if ( input ) { | |
| source = sources[ input.source ]; | |
| numParams = source.accessor.params.length; | |
| for ( var ndx = 0, len = vs.length; ndx < len; ndx ++ ) { | |
| ns.push( getConvertedVec3( source.data, vs[ ndx ] * numParams ) ); | |
| } | |
| } else { | |
| geom.calcNormals = true; | |
| } | |
| } | |
| if ( !ts ) { | |
| ts = { }; | |
| // check the vertices inputs | |
| input = this.vertices.input.TEXCOORD; | |
| if ( input ) { | |
| texture_sets.push( input.set ); | |
| source = sources[ input.source ]; | |
| numParams = source.accessor.params.length; | |
| for ( var ndx = 0, len = vs.length; ndx < len; ndx ++ ) { | |
| idx32 = vs[ ndx ] * numParams; | |
| if ( ts[ input.set ] === undefined ) ts[ input.set ] = [ ]; | |
| // invert the V | |
| ts[ input.set ].push( new THREE.Vector2( source.data[ idx32 ], 1.0 - source.data[ idx32 + 1 ] ) ); | |
| } | |
| } | |
| } | |
| if ( cs.length === 0 ) { | |
| // check the vertices inputs | |
| input = this.vertices.input.COLOR; | |
| if ( input ) { | |
| source = sources[ input.source ]; | |
| numParams = source.accessor.params.length; | |
| for ( var ndx = 0, len = vs.length; ndx < len; ndx ++ ) { | |
| idx32 = vs[ ndx ] * numParams; | |
| cs.push( new THREE.Color().setRGB( source.data[ idx32 ], source.data[ idx32 + 1 ], source.data[ idx32 + 2 ] ) ); | |
| } | |
| } | |
| } | |
| var face = null, faces = [], uv, uvArr; | |
| if ( vcount === 3 ) { | |
| faces.push( new THREE.Face3( vs[0], vs[1], vs[2], ns, cs.length ? cs : new THREE.Color() ) ); | |
| } else if ( vcount === 4 ) { | |
| faces.push( new THREE.Face3( vs[0], vs[1], vs[3], ns.length ? [ ns[0].clone(), ns[1].clone(), ns[3].clone() ] : [], cs.length ? [ cs[0], cs[1], cs[3] ] : new THREE.Color() ) ); | |
| faces.push( new THREE.Face3( vs[1], vs[2], vs[3], ns.length ? [ ns[1].clone(), ns[2].clone(), ns[3].clone() ] : [], cs.length ? [ cs[1], cs[2], cs[3] ] : new THREE.Color() ) ); | |
| } else if ( vcount > 4 && options.subdivideFaces ) { | |
| var clr = cs.length ? cs : new THREE.Color(), | |
| vec1, vec2, vec3, v1, v2, norm; | |
| // subdivide into multiple Face3s | |
| for ( k = 1; k < vcount - 1; ) { | |
| faces.push( new THREE.Face3( vs[0], vs[k], vs[k + 1], ns.length ? [ ns[0].clone(), ns[k ++].clone(), ns[k].clone() ] : [], clr ) ); | |
| } | |
| } | |
| if ( faces.length ) { | |
| for ( var ndx = 0, len = faces.length; ndx < len; ndx ++ ) { | |
| face = faces[ndx]; | |
| face.daeMaterial = primitive.material; | |
| geom.faces.push( face ); | |
| for ( k = 0; k < texture_sets.length; k ++ ) { | |
| uv = ts[ texture_sets[k] ]; | |
| if ( vcount > 4 ) { | |
| // Grab the right UVs for the vertices in this face | |
| uvArr = [ uv[0], uv[ndx + 1], uv[ndx + 2] ]; | |
| } else if ( vcount === 4 ) { | |
| if ( ndx === 0 ) { | |
| uvArr = [ uv[0], uv[1], uv[3] ]; | |
| } else { | |
| uvArr = [ uv[1].clone(), uv[2], uv[3].clone() ]; | |
| } | |
| } else { | |
| uvArr = [ uv[0], uv[1], uv[2] ]; | |
| } | |
| if ( geom.faceVertexUvs[k] === undefined ) { | |
| geom.faceVertexUvs[k] = []; | |
| } | |
| geom.faceVertexUvs[k].push( uvArr ); | |
| } | |
| } | |
| } else { | |
| console.log( 'dropped face with vcount ' + vcount + ' for geometry with id: ' + geom.id ); | |
| } | |
| i += maxOffset * vcount; | |
| } | |
| } | |
| }; | |
| function Polygons () { | |
| this.material = ""; | |
| this.count = 0; | |
| this.inputs = []; | |
| this.vcount = null; | |
| this.p = []; | |
| this.geometry = new THREE.Geometry(); | |
| } | |
| Polygons.prototype.setVertices = function ( vertices ) { | |
| for ( var i = 0; i < this.inputs.length; i ++ ) { | |
| if ( this.inputs[ i ].source === vertices.id ) { | |
| this.inputs[ i ].source = vertices.input[ 'POSITION' ].source; | |
| } | |
| } | |
| }; | |
| Polygons.prototype.parse = function ( element ) { | |
| this.material = element.getAttribute( 'material' ); | |
| this.count = _attr_as_int( element, 'count', 0 ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| switch ( child.nodeName ) { | |
| case 'input': | |
| this.inputs.push( ( new Input() ).parse( element.childNodes[ i ] ) ); | |
| break; | |
| case 'vcount': | |
| this.vcount = _ints( child.textContent ); | |
| break; | |
| case 'p': | |
| this.p.push( _ints( child.textContent ) ); | |
| break; | |
| case 'ph': | |
| console.warn( 'polygon holes not yet supported!' ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Polylist () { | |
| Polygons.call( this ); | |
| this.vcount = []; | |
| } | |
| Polylist.prototype = Object.create( Polygons.prototype ); | |
| Polylist.prototype.constructor = Polylist; | |
| function LineStrips() { | |
| Polygons.call( this ); | |
| this.vcount = 1; | |
| } | |
| LineStrips.prototype = Object.create( Polygons.prototype ); | |
| LineStrips.prototype.constructor = LineStrips; | |
| function Triangles () { | |
| Polygons.call( this ); | |
| this.vcount = 3; | |
| } | |
| Triangles.prototype = Object.create( Polygons.prototype ); | |
| Triangles.prototype.constructor = Triangles; | |
| function Accessor() { | |
| this.source = ""; | |
| this.count = 0; | |
| this.stride = 0; | |
| this.params = []; | |
| } | |
| Accessor.prototype.parse = function ( element ) { | |
| this.params = []; | |
| this.source = element.getAttribute( 'source' ); | |
| this.count = _attr_as_int( element, 'count', 0 ); | |
| this.stride = _attr_as_int( element, 'stride', 0 ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeName === 'param' ) { | |
| var param = {}; | |
| param[ 'name' ] = child.getAttribute( 'name' ); | |
| param[ 'type' ] = child.getAttribute( 'type' ); | |
| this.params.push( param ); | |
| } | |
| } | |
| return this; | |
| }; | |
| function Vertices() { | |
| this.input = {}; | |
| } | |
| Vertices.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute('id'); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| if ( element.childNodes[i].nodeName === 'input' ) { | |
| var input = ( new Input() ).parse( element.childNodes[ i ] ); | |
| this.input[ input.semantic ] = input; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Input () { | |
| this.semantic = ""; | |
| this.offset = 0; | |
| this.source = ""; | |
| this.set = 0; | |
| } | |
| Input.prototype.parse = function ( element ) { | |
| this.semantic = element.getAttribute('semantic'); | |
| this.source = element.getAttribute('source').replace(/^#/, ''); | |
| this.set = _attr_as_int(element, 'set', -1); | |
| this.offset = _attr_as_int(element, 'offset', 0); | |
| if ( this.semantic === 'TEXCOORD' && this.set < 0 ) { | |
| this.set = 0; | |
| } | |
| return this; | |
| }; | |
| function Source ( id ) { | |
| this.id = id; | |
| this.type = null; | |
| } | |
| Source.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| switch ( child.nodeName ) { | |
| case 'bool_array': | |
| this.data = _bools( child.textContent ); | |
| this.type = child.nodeName; | |
| break; | |
| case 'float_array': | |
| this.data = _floats( child.textContent ); | |
| this.type = child.nodeName; | |
| break; | |
| case 'int_array': | |
| this.data = _ints( child.textContent ); | |
| this.type = child.nodeName; | |
| break; | |
| case 'IDREF_array': | |
| case 'Name_array': | |
| this.data = _strings( child.textContent ); | |
| this.type = child.nodeName; | |
| break; | |
| case 'technique_common': | |
| for ( var j = 0; j < child.childNodes.length; j ++ ) { | |
| if ( child.childNodes[ j ].nodeName === 'accessor' ) { | |
| this.accessor = ( new Accessor() ).parse( child.childNodes[ j ] ); | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| // console.log(child.nodeName); | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| Source.prototype.read = function () { | |
| var result = []; | |
| //for (var i = 0; i < this.accessor.params.length; i++) { | |
| var param = this.accessor.params[ 0 ]; | |
| //console.log(param.name + " " + param.type); | |
| switch ( param.type ) { | |
| case 'IDREF': | |
| case 'Name': case 'name': | |
| case 'float': | |
| return this.data; | |
| case 'float4x4': | |
| for ( var j = 0; j < this.data.length; j += 16 ) { | |
| var s = this.data.slice( j, j + 16 ); | |
| var m = getConvertedMat4( s ); | |
| result.push( m ); | |
| } | |
| break; | |
| default: | |
| console.log( 'ColladaLoader: Source: Read dont know how to read ' + param.type + '.' ); | |
| break; | |
| } | |
| //} | |
| return result; | |
| }; | |
| function Material () { | |
| this.id = ""; | |
| this.name = ""; | |
| this.instance_effect = null; | |
| } | |
| Material.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| this.name = element.getAttribute( 'name' ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| if ( element.childNodes[ i ].nodeName === 'instance_effect' ) { | |
| this.instance_effect = ( new InstanceEffect() ).parse( element.childNodes[ i ] ); | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function ColorOrTexture () { | |
| this.color = new THREE.Color(); | |
| this.color.setRGB( Math.random(), Math.random(), Math.random() ); | |
| this.color.a = 1.0; | |
| this.texture = null; | |
| this.texcoord = null; | |
| this.texOpts = null; | |
| } | |
| ColorOrTexture.prototype.isColor = function () { | |
| return ( this.texture === null ); | |
| }; | |
| ColorOrTexture.prototype.isTexture = function () { | |
| return ( this.texture != null ); | |
| }; | |
| ColorOrTexture.prototype.parse = function ( element ) { | |
| if (element.nodeName === 'transparent') { | |
| this.opaque = element.getAttribute('opaque'); | |
| } | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'color': | |
| var rgba = _floats( child.textContent ); | |
| this.color = new THREE.Color(); | |
| this.color.setRGB( rgba[0], rgba[1], rgba[2] ); | |
| this.color.a = rgba[3]; | |
| break; | |
| case 'texture': | |
| this.texture = child.getAttribute('texture'); | |
| this.texcoord = child.getAttribute('texcoord'); | |
| // Defaults from: | |
| // https://collada.org/mediawiki/index.php/Maya_texture_placement_MAYA_extension | |
| this.texOpts = { | |
| offsetU: 0, | |
| offsetV: 0, | |
| repeatU: 1, | |
| repeatV: 1, | |
| wrapU: 1, | |
| wrapV: 1 | |
| }; | |
| this.parseTexture( child ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| ColorOrTexture.prototype.parseTexture = function ( element ) { | |
| if ( ! element.childNodes ) return this; | |
| // This should be supported by Maya, 3dsMax, and MotionBuilder | |
| if ( element.childNodes[1] && element.childNodes[1].nodeName === 'extra' ) { | |
| element = element.childNodes[1]; | |
| if ( element.childNodes[1] && element.childNodes[1].nodeName === 'technique' ) { | |
| element = element.childNodes[1]; | |
| } | |
| } | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| switch ( child.nodeName ) { | |
| case 'offsetU': | |
| case 'offsetV': | |
| case 'repeatU': | |
| case 'repeatV': | |
| this.texOpts[ child.nodeName ] = parseFloat( child.textContent ); | |
| break; | |
| case 'wrapU': | |
| case 'wrapV': | |
| // some dae have a value of true which becomes NaN via parseInt | |
| if ( child.textContent.toUpperCase() === 'TRUE' ) { | |
| this.texOpts[ child.nodeName ] = 1; | |
| } else { | |
| this.texOpts[ child.nodeName ] = parseInt( child.textContent ); | |
| } | |
| break; | |
| default: | |
| this.texOpts[ child.nodeName ] = child.textContent; | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Shader ( type, effect ) { | |
| this.type = type; | |
| this.effect = effect; | |
| this.material = null; | |
| } | |
| Shader.prototype.parse = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'emission': | |
| case 'diffuse': | |
| case 'specular': | |
| case 'transparent': | |
| this[ child.nodeName ] = ( new ColorOrTexture() ).parse( child ); | |
| break; | |
| case 'bump': | |
| // If 'bumptype' is 'heightfield', create a 'bump' property | |
| // Else if 'bumptype' is 'normalmap', create a 'normal' property | |
| // (Default to 'bump') | |
| var bumpType = child.getAttribute( 'bumptype' ); | |
| if ( bumpType ) { | |
| if ( bumpType.toLowerCase() === "heightfield" ) { | |
| this[ 'bump' ] = ( new ColorOrTexture() ).parse( child ); | |
| } else if ( bumpType.toLowerCase() === "normalmap" ) { | |
| this[ 'normal' ] = ( new ColorOrTexture() ).parse( child ); | |
| } else { | |
| console.error( "Shader.prototype.parse: Invalid value for attribute 'bumptype' (" + bumpType + ") - valid bumptypes are 'HEIGHTFIELD' and 'NORMALMAP' - defaulting to 'HEIGHTFIELD'" ); | |
| this[ 'bump' ] = ( new ColorOrTexture() ).parse( child ); | |
| } | |
| } else { | |
| console.warn( "Shader.prototype.parse: Attribute 'bumptype' missing from bump node - defaulting to 'HEIGHTFIELD'" ); | |
| this[ 'bump' ] = ( new ColorOrTexture() ).parse( child ); | |
| } | |
| break; | |
| case 'shininess': | |
| case 'reflectivity': | |
| case 'index_of_refraction': | |
| case 'transparency': | |
| var f = child.querySelectorAll('float'); | |
| if ( f.length > 0 ) | |
| this[ child.nodeName ] = parseFloat( f[ 0 ].textContent ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| this.create(); | |
| return this; | |
| }; | |
| Shader.prototype.create = function() { | |
| var props = {}; | |
| var transparent = false; | |
| if (this['transparency'] !== undefined && this['transparent'] !== undefined) { | |
| // convert transparent color RBG to average value | |
| var transparentColor = this['transparent']; | |
| var transparencyLevel = (this.transparent.color.r + this.transparent.color.g + this.transparent.color.b) / 3 * this.transparency; | |
| if (transparencyLevel > 0) { | |
| transparent = true; | |
| props[ 'transparent' ] = true; | |
| props[ 'opacity' ] = 1 - transparencyLevel; | |
| } | |
| } | |
| var keys = { | |
| 'diffuse':'map', | |
| 'ambient':'lightMap', | |
| 'specular':'specularMap', | |
| 'emission':'emissionMap', | |
| 'bump':'bumpMap', | |
| 'normal':'normalMap' | |
| }; | |
| for ( var prop in this ) { | |
| switch ( prop ) { | |
| case 'ambient': | |
| case 'emission': | |
| case 'diffuse': | |
| case 'specular': | |
| case 'bump': | |
| case 'normal': | |
| var cot = this[ prop ]; | |
| if ( cot instanceof ColorOrTexture ) { | |
| if ( cot.isTexture() ) { | |
| var samplerId = cot.texture; | |
| var surfaceId = this.effect.sampler[samplerId]; | |
| if ( surfaceId !== undefined && surfaceId.source !== undefined ) { | |
| var surface = this.effect.surface[surfaceId.source]; | |
| if ( surface !== undefined ) { | |
| var image = images[ surface.init_from ]; | |
| if ( image ) { | |
| var url = baseUrl + image.init_from; | |
| var texture; | |
| var loader = THREE.Loader.Handlers.get( url ); | |
| if ( loader !== null ) { | |
| texture = loader.load( url ); | |
| } else { | |
| texture = new THREE.Texture(); | |
| loadTextureImage( texture, url ); | |
| } | |
| texture.wrapS = cot.texOpts.wrapU ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping; | |
| texture.wrapT = cot.texOpts.wrapV ? THREE.RepeatWrapping : THREE.ClampToEdgeWrapping; | |
| texture.offset.x = cot.texOpts.offsetU; | |
| texture.offset.y = cot.texOpts.offsetV; | |
| texture.repeat.x = cot.texOpts.repeatU; | |
| texture.repeat.y = cot.texOpts.repeatV; | |
| props[keys[prop]] = texture; | |
| // Texture with baked lighting? | |
| if (prop === 'emission') props['emissive'] = 0xffffff; | |
| } | |
| } | |
| } | |
| } else if ( prop === 'diffuse' || !transparent ) { | |
| if ( prop === 'emission' ) { | |
| props[ 'emissive' ] = cot.color.getHex(); | |
| } else { | |
| props[ prop ] = cot.color.getHex(); | |
| } | |
| } | |
| } | |
| break; | |
| case 'shininess': | |
| props[ prop ] = this[ prop ]; | |
| break; | |
| case 'reflectivity': | |
| props[ prop ] = this[ prop ]; | |
| if ( props[ prop ] > 0.0 ) props['envMap'] = options.defaultEnvMap; | |
| props['combine'] = THREE.MixOperation; //mix regular shading with reflective component | |
| break; | |
| case 'index_of_refraction': | |
| props[ 'refractionRatio' ] = this[ prop ]; //TODO: "index_of_refraction" becomes "refractionRatio" in shader, but I'm not sure if the two are actually comparable | |
| if ( this[ prop ] !== 1.0 ) props['envMap'] = options.defaultEnvMap; | |
| break; | |
| case 'transparency': | |
| // gets figured out up top | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| props[ 'shading' ] = preferredShading; | |
| props[ 'side' ] = this.effect.doubleSided ? THREE.DoubleSide : THREE.FrontSide; | |
| if ( props.diffuse !== undefined ) { | |
| props.color = props.diffuse; | |
| delete props.diffuse; | |
| } | |
| switch ( this.type ) { | |
| case 'constant': | |
| if (props.emissive != undefined) props.color = props.emissive; | |
| this.material = new THREE.MeshBasicMaterial( props ); | |
| break; | |
| case 'phong': | |
| case 'blinn': | |
| this.material = new THREE.MeshPhongMaterial( props ); | |
| break; | |
| case 'lambert': | |
| default: | |
| this.material = new THREE.MeshLambertMaterial( props ); | |
| break; | |
| } | |
| return this.material; | |
| }; | |
| function Surface ( effect ) { | |
| this.effect = effect; | |
| this.init_from = null; | |
| this.format = null; | |
| } | |
| Surface.prototype.parse = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'init_from': | |
| this.init_from = child.textContent; | |
| break; | |
| case 'format': | |
| this.format = child.textContent; | |
| break; | |
| default: | |
| console.log( "unhandled Surface prop: " + child.nodeName ); | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Sampler2D ( effect ) { | |
| this.effect = effect; | |
| this.source = null; | |
| this.wrap_s = null; | |
| this.wrap_t = null; | |
| this.minfilter = null; | |
| this.magfilter = null; | |
| this.mipfilter = null; | |
| } | |
| Sampler2D.prototype.parse = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'source': | |
| this.source = child.textContent; | |
| break; | |
| case 'minfilter': | |
| this.minfilter = child.textContent; | |
| break; | |
| case 'magfilter': | |
| this.magfilter = child.textContent; | |
| break; | |
| case 'mipfilter': | |
| this.mipfilter = child.textContent; | |
| break; | |
| case 'wrap_s': | |
| this.wrap_s = child.textContent; | |
| break; | |
| case 'wrap_t': | |
| this.wrap_t = child.textContent; | |
| break; | |
| default: | |
| console.log( "unhandled Sampler2D prop: " + child.nodeName ); | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Effect () { | |
| this.id = ""; | |
| this.name = ""; | |
| this.shader = null; | |
| this.surface = {}; | |
| this.sampler = {}; | |
| } | |
| Effect.prototype.create = function () { | |
| if ( this.shader === null ) { | |
| return null; | |
| } | |
| }; | |
| Effect.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| this.name = element.getAttribute( 'name' ); | |
| extractDoubleSided( this, element ); | |
| this.shader = null; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'profile_COMMON': | |
| this.parseTechnique( this.parseProfileCOMMON( child ) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| Effect.prototype.parseNewparam = function ( element ) { | |
| var sid = element.getAttribute( 'sid' ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'surface': | |
| this.surface[sid] = ( new Surface( this ) ).parse( child ); | |
| break; | |
| case 'sampler2D': | |
| this.sampler[sid] = ( new Sampler2D( this ) ).parse( child ); | |
| break; | |
| case 'extra': | |
| break; | |
| default: | |
| console.log( child.nodeName ); | |
| break; | |
| } | |
| } | |
| }; | |
| Effect.prototype.parseProfileCOMMON = function ( element ) { | |
| var technique; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'profile_COMMON': | |
| this.parseProfileCOMMON( child ); | |
| break; | |
| case 'technique': | |
| technique = child; | |
| break; | |
| case 'newparam': | |
| this.parseNewparam( child ); | |
| break; | |
| case 'image': | |
| var _image = ( new _Image() ).parse( child ); | |
| images[ _image.id ] = _image; | |
| break; | |
| case 'extra': | |
| break; | |
| default: | |
| console.log( child.nodeName ); | |
| break; | |
| } | |
| } | |
| return technique; | |
| }; | |
| Effect.prototype.parseTechnique = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'constant': | |
| case 'lambert': | |
| case 'blinn': | |
| case 'phong': | |
| this.shader = ( new Shader( child.nodeName, this ) ).parse( child ); | |
| break; | |
| case 'extra': | |
| this.parseExtra(child); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| }; | |
| Effect.prototype.parseExtra = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'technique': | |
| this.parseExtraTechnique( child ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| }; | |
| Effect.prototype.parseExtraTechnique = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[i]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'bump': | |
| this.shader.parse( element ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| }; | |
| function InstanceEffect () { | |
| this.url = ""; | |
| } | |
| InstanceEffect.prototype.parse = function ( element ) { | |
| this.url = element.getAttribute( 'url' ).replace( /^#/, '' ); | |
| return this; | |
| }; | |
| function Animation() { | |
| this.id = ""; | |
| this.name = ""; | |
| this.source = {}; | |
| this.sampler = []; | |
| this.channel = []; | |
| } | |
| Animation.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| this.name = element.getAttribute( 'name' ); | |
| this.source = {}; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'animation': | |
| var anim = ( new Animation() ).parse( child ); | |
| for ( var src in anim.source ) { | |
| this.source[ src ] = anim.source[ src ]; | |
| } | |
| for ( var j = 0; j < anim.channel.length; j ++ ) { | |
| this.channel.push( anim.channel[ j ] ); | |
| this.sampler.push( anim.sampler[ j ] ); | |
| } | |
| break; | |
| case 'source': | |
| var src = ( new Source() ).parse( child ); | |
| this.source[ src.id ] = src; | |
| break; | |
| case 'sampler': | |
| this.sampler.push( ( new Sampler( this ) ).parse( child ) ); | |
| break; | |
| case 'channel': | |
| this.channel.push( ( new Channel( this ) ).parse( child ) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Channel( animation ) { | |
| this.animation = animation; | |
| this.source = ""; | |
| this.target = ""; | |
| this.fullSid = null; | |
| this.sid = null; | |
| this.dotSyntax = null; | |
| this.arrSyntax = null; | |
| this.arrIndices = null; | |
| this.member = null; | |
| } | |
| Channel.prototype.parse = function ( element ) { | |
| this.source = element.getAttribute( 'source' ).replace( /^#/, '' ); | |
| this.target = element.getAttribute( 'target' ); | |
| var parts = this.target.split( '/' ); | |
| var id = parts.shift(); | |
| var sid = parts.shift(); | |
| var dotSyntax = ( sid.indexOf(".") >= 0 ); | |
| var arrSyntax = ( sid.indexOf("(") >= 0 ); | |
| if ( dotSyntax ) { | |
| parts = sid.split("."); | |
| this.sid = parts.shift(); | |
| this.member = parts.shift(); | |
| } else if ( arrSyntax ) { | |
| var arrIndices = sid.split("("); | |
| this.sid = arrIndices.shift(); | |
| for (var j = 0; j < arrIndices.length; j ++ ) { | |
| arrIndices[j] = parseInt( arrIndices[j].replace(/\)/, '') ); | |
| } | |
| this.arrIndices = arrIndices; | |
| } else { | |
| this.sid = sid; | |
| } | |
| this.fullSid = sid; | |
| this.dotSyntax = dotSyntax; | |
| this.arrSyntax = arrSyntax; | |
| return this; | |
| }; | |
| function Sampler ( animation ) { | |
| this.id = ""; | |
| this.animation = animation; | |
| this.inputs = []; | |
| this.input = null; | |
| this.output = null; | |
| this.strideOut = null; | |
| this.interpolation = null; | |
| this.startTime = null; | |
| this.endTime = null; | |
| this.duration = 0; | |
| } | |
| Sampler.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| this.inputs = []; | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'input': | |
| this.inputs.push( (new Input()).parse( child ) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| Sampler.prototype.create = function () { | |
| for ( var i = 0; i < this.inputs.length; i ++ ) { | |
| var input = this.inputs[ i ]; | |
| var source = this.animation.source[ input.source ]; | |
| switch ( input.semantic ) { | |
| case 'INPUT': | |
| this.input = source.read(); | |
| break; | |
| case 'OUTPUT': | |
| this.output = source.read(); | |
| this.strideOut = source.accessor.stride; | |
| break; | |
| case 'INTERPOLATION': | |
| this.interpolation = source.read(); | |
| break; | |
| case 'IN_TANGENT': | |
| break; | |
| case 'OUT_TANGENT': | |
| break; | |
| default: | |
| console.log(input.semantic); | |
| break; | |
| } | |
| } | |
| this.startTime = 0; | |
| this.endTime = 0; | |
| this.duration = 0; | |
| if ( this.input.length ) { | |
| this.startTime = 100000000; | |
| this.endTime = -100000000; | |
| for ( var i = 0; i < this.input.length; i ++ ) { | |
| this.startTime = Math.min( this.startTime, this.input[ i ] ); | |
| this.endTime = Math.max( this.endTime, this.input[ i ] ); | |
| } | |
| this.duration = this.endTime - this.startTime; | |
| } | |
| }; | |
| Sampler.prototype.getData = function ( type, ndx, member ) { | |
| var data; | |
| if ( type === 'matrix' && this.strideOut === 16 ) { | |
| data = this.output[ ndx ]; | |
| } else if ( this.strideOut > 1 ) { | |
| data = []; | |
| ndx *= this.strideOut; | |
| for ( var i = 0; i < this.strideOut; ++ i ) { | |
| data[ i ] = this.output[ ndx + i ]; | |
| } | |
| if ( this.strideOut === 3 ) { | |
| switch ( type ) { | |
| case 'rotate': | |
| case 'translate': | |
| fixCoords( data, -1 ); | |
| break; | |
| case 'scale': | |
| fixCoords( data, 1 ); | |
| break; | |
| } | |
| } else if ( this.strideOut === 4 && type === 'matrix' ) { | |
| fixCoords( data, -1 ); | |
| } | |
| } else { | |
| data = this.output[ ndx ]; | |
| if ( member && type === 'translate' ) { | |
| data = getConvertedTranslation( member, data ); | |
| } | |
| } | |
| return data; | |
| }; | |
| function Key ( time ) { | |
| this.targets = []; | |
| this.time = time; | |
| } | |
| Key.prototype.addTarget = function ( fullSid, transform, member, data ) { | |
| this.targets.push( { | |
| sid: fullSid, | |
| member: member, | |
| transform: transform, | |
| data: data | |
| } ); | |
| }; | |
| Key.prototype.apply = function ( opt_sid ) { | |
| for ( var i = 0; i < this.targets.length; ++ i ) { | |
| var target = this.targets[ i ]; | |
| if ( !opt_sid || target.sid === opt_sid ) { | |
| target.transform.update( target.data, target.member ); | |
| } | |
| } | |
| }; | |
| Key.prototype.getTarget = function ( fullSid ) { | |
| for ( var i = 0; i < this.targets.length; ++ i ) { | |
| if ( this.targets[ i ].sid === fullSid ) { | |
| return this.targets[ i ]; | |
| } | |
| } | |
| return null; | |
| }; | |
| Key.prototype.hasTarget = function ( fullSid ) { | |
| for ( var i = 0; i < this.targets.length; ++ i ) { | |
| if ( this.targets[ i ].sid === fullSid ) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| // TODO: Currently only doing linear interpolation. Should support full COLLADA spec. | |
| Key.prototype.interpolate = function ( nextKey, time ) { | |
| for ( var i = 0, l = this.targets.length; i < l; i ++ ) { | |
| var target = this.targets[ i ], | |
| nextTarget = nextKey.getTarget( target.sid ), | |
| data; | |
| if ( target.transform.type !== 'matrix' && nextTarget ) { | |
| var scale = ( time - this.time ) / ( nextKey.time - this.time ), | |
| nextData = nextTarget.data, | |
| prevData = target.data; | |
| if ( scale < 0 ) scale = 0; | |
| if ( scale > 1 ) scale = 1; | |
| if ( prevData.length ) { | |
| data = []; | |
| for ( var j = 0; j < prevData.length; ++ j ) { | |
| data[ j ] = prevData[ j ] + ( nextData[ j ] - prevData[ j ] ) * scale; | |
| } | |
| } else { | |
| data = prevData + ( nextData - prevData ) * scale; | |
| } | |
| } else { | |
| data = target.data; | |
| } | |
| target.transform.update( data, target.member ); | |
| } | |
| }; | |
| // Camera | |
| function Camera() { | |
| this.id = ""; | |
| this.name = ""; | |
| this.technique = ""; | |
| } | |
| Camera.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| this.name = element.getAttribute( 'name' ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'optics': | |
| this.parseOptics( child ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| Camera.prototype.parseOptics = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| if ( element.childNodes[ i ].nodeName === 'technique_common' ) { | |
| var technique = element.childNodes[ i ]; | |
| for ( var j = 0; j < technique.childNodes.length; j ++ ) { | |
| this.technique = technique.childNodes[ j ].nodeName; | |
| if ( this.technique === 'perspective' ) { | |
| var perspective = technique.childNodes[ j ]; | |
| for ( var k = 0; k < perspective.childNodes.length; k ++ ) { | |
| var param = perspective.childNodes[ k ]; | |
| switch ( param.nodeName ) { | |
| case 'yfov': | |
| this.yfov = param.textContent; | |
| break; | |
| case 'xfov': | |
| this.xfov = param.textContent; | |
| break; | |
| case 'znear': | |
| this.znear = param.textContent; | |
| break; | |
| case 'zfar': | |
| this.zfar = param.textContent; | |
| break; | |
| case 'aspect_ratio': | |
| this.aspect_ratio = param.textContent; | |
| break; | |
| } | |
| } | |
| } else if ( this.technique === 'orthographic' ) { | |
| var orthographic = technique.childNodes[ j ]; | |
| for ( var k = 0; k < orthographic.childNodes.length; k ++ ) { | |
| var param = orthographic.childNodes[ k ]; | |
| switch ( param.nodeName ) { | |
| case 'xmag': | |
| this.xmag = param.textContent; | |
| break; | |
| case 'ymag': | |
| this.ymag = param.textContent; | |
| break; | |
| case 'znear': | |
| this.znear = param.textContent; | |
| break; | |
| case 'zfar': | |
| this.zfar = param.textContent; | |
| break; | |
| case 'aspect_ratio': | |
| this.aspect_ratio = param.textContent; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return this; | |
| }; | |
| function InstanceCamera() { | |
| this.url = ""; | |
| } | |
| InstanceCamera.prototype.parse = function ( element ) { | |
| this.url = element.getAttribute('url').replace(/^#/, ''); | |
| return this; | |
| }; | |
| // Light | |
| function Light() { | |
| this.id = ""; | |
| this.name = ""; | |
| this.technique = ""; | |
| } | |
| Light.prototype.parse = function ( element ) { | |
| this.id = element.getAttribute( 'id' ); | |
| this.name = element.getAttribute( 'name' ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'technique_common': | |
| this.parseCommon( child ); | |
| break; | |
| case 'technique': | |
| this.parseTechnique( child ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| Light.prototype.parseCommon = function ( element ) { | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| switch ( element.childNodes[ i ].nodeName ) { | |
| case 'directional': | |
| case 'point': | |
| case 'spot': | |
| case 'ambient': | |
| this.technique = element.childNodes[ i ].nodeName; | |
| var light = element.childNodes[ i ]; | |
| for ( var j = 0; j < light.childNodes.length; j ++ ) { | |
| var child = light.childNodes[j]; | |
| switch ( child.nodeName ) { | |
| case 'color': | |
| var rgba = _floats( child.textContent ); | |
| this.color = new THREE.Color(0); | |
| this.color.setRGB( rgba[0], rgba[1], rgba[2] ); | |
| this.color.a = rgba[3]; | |
| break; | |
| case 'falloff_angle': | |
| this.falloff_angle = parseFloat( child.textContent ); | |
| break; | |
| case 'quadratic_attenuation': | |
| var f = parseFloat( child.textContent ); | |
| this.distance = f ? Math.sqrt( 1 / f ) : 0; | |
| } | |
| } | |
| } | |
| } | |
| return this; | |
| }; | |
| Light.prototype.parseTechnique = function ( element ) { | |
| this.profile = element.getAttribute( 'profile' ); | |
| for ( var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| switch ( child.nodeName ) { | |
| case 'intensity': | |
| this.intensity = parseFloat(child.textContent); | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function InstanceLight() { | |
| this.url = ""; | |
| } | |
| InstanceLight.prototype.parse = function ( element ) { | |
| this.url = element.getAttribute('url').replace(/^#/, ''); | |
| return this; | |
| }; | |
| function KinematicsModel( ) { | |
| this.id = ''; | |
| this.name = ''; | |
| this.joints = []; | |
| this.links = []; | |
| } | |
| KinematicsModel.prototype.parse = function( element ) { | |
| this.id = element.getAttribute('id'); | |
| this.name = element.getAttribute('name'); | |
| this.joints = []; | |
| this.links = []; | |
| for (var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'technique_common': | |
| this.parseCommon(child); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| KinematicsModel.prototype.parseCommon = function( element ) { | |
| for (var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( element.childNodes[ i ].nodeName ) { | |
| case 'joint': | |
| this.joints.push( (new Joint()).parse(child) ); | |
| break; | |
| case 'link': | |
| this.links.push( (new Link()).parse(child) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Joint( ) { | |
| this.sid = ''; | |
| this.name = ''; | |
| this.axis = new THREE.Vector3(); | |
| this.limits = { | |
| min: 0, | |
| max: 0 | |
| }; | |
| this.type = ''; | |
| this.static = false; | |
| this.zeroPosition = 0.0; | |
| this.middlePosition = 0.0; | |
| } | |
| Joint.prototype.parse = function( element ) { | |
| this.sid = element.getAttribute('sid'); | |
| this.name = element.getAttribute('name'); | |
| this.axis = new THREE.Vector3(); | |
| this.limits = { | |
| min: 0, | |
| max: 0 | |
| }; | |
| this.type = ''; | |
| this.static = false; | |
| this.zeroPosition = 0.0; | |
| this.middlePosition = 0.0; | |
| var axisElement = element.querySelector('axis'); | |
| var _axis = _floats(axisElement.textContent); | |
| this.axis = getConvertedVec3(_axis, 0); | |
| var min = element.querySelector('limits min') ? parseFloat(element.querySelector('limits min').textContent) : -360; | |
| var max = element.querySelector('limits max') ? parseFloat(element.querySelector('limits max').textContent) : 360; | |
| this.limits = { | |
| min: min, | |
| max: max | |
| }; | |
| var jointTypes = [ 'prismatic', 'revolute' ]; | |
| for (var i = 0; i < jointTypes.length; i ++ ) { | |
| var type = jointTypes[ i ]; | |
| var jointElement = element.querySelector(type); | |
| if ( jointElement ) { | |
| this.type = type; | |
| } | |
| } | |
| // if the min is equal to or somehow greater than the max, consider the joint static | |
| if ( this.limits.min >= this.limits.max ) { | |
| this.static = true; | |
| } | |
| this.middlePosition = (this.limits.min + this.limits.max) / 2.0; | |
| return this; | |
| }; | |
| function Link( ) { | |
| this.sid = ''; | |
| this.name = ''; | |
| this.transforms = []; | |
| this.attachments = []; | |
| } | |
| Link.prototype.parse = function( element ) { | |
| this.sid = element.getAttribute('sid'); | |
| this.name = element.getAttribute('name'); | |
| this.transforms = []; | |
| this.attachments = []; | |
| for (var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'attachment_full': | |
| this.attachments.push( (new Attachment()).parse(child) ); | |
| break; | |
| case 'rotate': | |
| case 'translate': | |
| case 'matrix': | |
| this.transforms.push( (new Transform()).parse(child) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function Attachment( ) { | |
| this.joint = ''; | |
| this.transforms = []; | |
| this.links = []; | |
| } | |
| Attachment.prototype.parse = function( element ) { | |
| this.joint = element.getAttribute('joint').split('/').pop(); | |
| this.links = []; | |
| for (var i = 0; i < element.childNodes.length; i ++ ) { | |
| var child = element.childNodes[ i ]; | |
| if ( child.nodeType != 1 ) continue; | |
| switch ( child.nodeName ) { | |
| case 'link': | |
| this.links.push( (new Link()).parse(child) ); | |
| break; | |
| case 'rotate': | |
| case 'translate': | |
| case 'matrix': | |
| this.transforms.push( (new Transform()).parse(child) ); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| return this; | |
| }; | |
| function _source( element ) { | |
| var id = element.getAttribute( 'id' ); | |
| if ( sources[ id ] != undefined ) { | |
| return sources[ id ]; | |
| } | |
| sources[ id ] = ( new Source(id )).parse( element ); | |
| return sources[ id ]; | |
| } | |
| function _nsResolver( nsPrefix ) { | |
| if ( nsPrefix === "dae" ) { | |
| return "http://www.collada.org/2005/11/COLLADASchema"; | |
| } | |
| return null; | |
| } | |
| function _bools( str ) { | |
| var raw = _strings( str ); | |
| var data = []; | |
| for ( var i = 0, l = raw.length; i < l; i ++ ) { | |
| data.push( (raw[i] === 'true' || raw[i] === '1') ? true : false ); | |
| } | |
| return data; | |
| } | |
| function _floats( str ) { | |
| var raw = _strings(str); | |
| var data = []; | |
| for ( var i = 0, l = raw.length; i < l; i ++ ) { | |
| data.push( parseFloat( raw[ i ] ) ); | |
| } | |
| return data; | |
| } | |
| function _ints( str ) { | |
| var raw = _strings( str ); | |
| var data = []; | |
| for ( var i = 0, l = raw.length; i < l; i ++ ) { | |
| data.push( parseInt( raw[ i ], 10 ) ); | |
| } | |
| return data; | |
| } | |
| function _strings( str ) { | |
| return ( str.length > 0 ) ? _trimString( str ).split( /\s+/ ) : []; | |
| } | |
| function _trimString( str ) { | |
| return str.replace( /^\s+/, "" ).replace( /\s+$/, "" ); | |
| } | |
| function _attr_as_float( element, name, defaultValue ) { | |
| if ( element.hasAttribute( name ) ) { | |
| return parseFloat( element.getAttribute( name ) ); | |
| } else { | |
| return defaultValue; | |
| } | |
| } | |
| function _attr_as_int( element, name, defaultValue ) { | |
| if ( element.hasAttribute( name ) ) { | |
| return parseInt( element.getAttribute( name ), 10) ; | |
| } else { | |
| return defaultValue; | |
| } | |
| } | |
| function _attr_as_string( element, name, defaultValue ) { | |
| if ( element.hasAttribute( name ) ) { | |
| return element.getAttribute( name ); | |
| } else { | |
| return defaultValue; | |
| } | |
| } | |
| function _format_float( f, num ) { | |
| if ( f === undefined ) { | |
| var s = '0.'; | |
| while ( s.length < num + 2 ) { | |
| s += '0'; | |
| } | |
| return s; | |
| } | |
| num = num || 2; | |
| var parts = f.toString().split( '.' ); | |
| parts[ 1 ] = parts.length > 1 ? parts[ 1 ].substr( 0, num ) : "0"; | |
| while ( parts[ 1 ].length < num ) { | |
| parts[ 1 ] += '0'; | |
| } | |
| return parts.join( '.' ); | |
| } | |
| function loadTextureImage ( texture, url ) { | |
| var loader = new THREE.ImageLoader(); | |
| loader.load( url, function ( image ) { | |
| texture.image = image; | |
| texture.needsUpdate = true; | |
| } ); | |
| } | |
| function extractDoubleSided( obj, element ) { | |
| obj.doubleSided = false; | |
| var node = element.querySelectorAll('extra double_sided')[0]; | |
| if ( node ) { | |
| if ( node && parseInt( node.textContent, 10 ) === 1 ) { | |
| obj.doubleSided = true; | |
| } | |
| } | |
| } | |
| // Up axis conversion | |
| function setUpConversion() { | |
| if ( options.convertUpAxis !== true || colladaUp === options.upAxis ) { | |
| upConversion = null; | |
| } else { | |
| switch ( colladaUp ) { | |
| case 'X': | |
| upConversion = options.upAxis === 'Y' ? 'XtoY' : 'XtoZ'; | |
| break; | |
| case 'Y': | |
| upConversion = options.upAxis === 'X' ? 'YtoX' : 'YtoZ'; | |
| break; | |
| case 'Z': | |
| upConversion = options.upAxis === 'X' ? 'ZtoX' : 'ZtoY'; | |
| break; | |
| } | |
| } | |
| } | |
| function fixCoords( data, sign ) { | |
| if ( options.convertUpAxis !== true || colladaUp === options.upAxis ) { | |
| return; | |
| } | |
| switch ( upConversion ) { | |
| case 'XtoY': | |
| var tmp = data[ 0 ]; | |
| data[ 0 ] = sign * data[ 1 ]; | |
| data[ 1 ] = tmp; | |
| break; | |
| case 'XtoZ': | |
| var tmp = data[ 2 ]; | |
| data[ 2 ] = data[ 1 ]; | |
| data[ 1 ] = data[ 0 ]; | |
| data[ 0 ] = tmp; | |
| break; | |
| case 'YtoX': | |
| var tmp = data[ 0 ]; | |
| data[ 0 ] = data[ 1 ]; | |
| data[ 1 ] = sign * tmp; | |
| break; | |
| case 'YtoZ': | |
| var tmp = data[ 1 ]; | |
| data[ 1 ] = sign * data[ 2 ]; | |
| data[ 2 ] = tmp; | |
| break; | |
| case 'ZtoX': | |
| var tmp = data[ 0 ]; | |
| data[ 0 ] = data[ 1 ]; | |
| data[ 1 ] = data[ 2 ]; | |
| data[ 2 ] = tmp; | |
| break; | |
| case 'ZtoY': | |
| var tmp = data[ 1 ]; | |
| data[ 1 ] = data[ 2 ]; | |
| data[ 2 ] = sign * tmp; | |
| break; | |
| } | |
| } | |
| function getConvertedTranslation( axis, data ) { | |
| if ( options.convertUpAxis !== true || colladaUp === options.upAxis ) { | |
| return data; | |
| } | |
| switch ( axis ) { | |
| case 'X': | |
| data = upConversion === 'XtoY' ? data * -1 : data; | |
| break; | |
| case 'Y': | |
| data = upConversion === 'YtoZ' || upConversion === 'YtoX' ? data * -1 : data; | |
| break; | |
| case 'Z': | |
| data = upConversion === 'ZtoY' ? data * -1 : data ; | |
| break; | |
| default: | |
| break; | |
| } | |
| return data; | |
| } | |
| function getConvertedVec3( data, offset ) { | |
| var arr = [ data[ offset ], data[ offset + 1 ], data[ offset + 2 ] ]; | |
| fixCoords( arr, -1 ); | |
| return new THREE.Vector3( arr[ 0 ], arr[ 1 ], arr[ 2 ] ); | |
| } | |
| function getConvertedMat4( data ) { | |
| if ( options.convertUpAxis ) { | |
| // First fix rotation and scale | |
| // Columns first | |
| var arr = [ data[ 0 ], data[ 4 ], data[ 8 ] ]; | |
| fixCoords( arr, -1 ); | |
| data[ 0 ] = arr[ 0 ]; | |
| data[ 4 ] = arr[ 1 ]; | |
| data[ 8 ] = arr[ 2 ]; | |
| arr = [ data[ 1 ], data[ 5 ], data[ 9 ] ]; | |
| fixCoords( arr, -1 ); | |
| data[ 1 ] = arr[ 0 ]; | |
| data[ 5 ] = arr[ 1 ]; | |
| data[ 9 ] = arr[ 2 ]; | |
| arr = [ data[ 2 ], data[ 6 ], data[ 10 ] ]; | |
| fixCoords( arr, -1 ); | |
| data[ 2 ] = arr[ 0 ]; | |
| data[ 6 ] = arr[ 1 ]; | |
| data[ 10 ] = arr[ 2 ]; | |
| // Rows second | |
| arr = [ data[ 0 ], data[ 1 ], data[ 2 ] ]; | |
| fixCoords( arr, -1 ); | |
| data[ 0 ] = arr[ 0 ]; | |
| data[ 1 ] = arr[ 1 ]; | |
| data[ 2 ] = arr[ 2 ]; | |
| arr = [ data[ 4 ], data[ 5 ], data[ 6 ] ]; | |
| fixCoords( arr, -1 ); | |
| data[ 4 ] = arr[ 0 ]; | |
| data[ 5 ] = arr[ 1 ]; | |
| data[ 6 ] = arr[ 2 ]; | |
| arr = [ data[ 8 ], data[ 9 ], data[ 10 ] ]; | |
| fixCoords( arr, -1 ); | |
| data[ 8 ] = arr[ 0 ]; | |
| data[ 9 ] = arr[ 1 ]; | |
| data[ 10 ] = arr[ 2 ]; | |
| // Now fix translation | |
| arr = [ data[ 3 ], data[ 7 ], data[ 11 ] ]; | |
| fixCoords( arr, -1 ); | |
| data[ 3 ] = arr[ 0 ]; | |
| data[ 7 ] = arr[ 1 ]; | |
| data[ 11 ] = arr[ 2 ]; | |
| } | |
| return new THREE.Matrix4().set( | |
| data[0], data[1], data[2], data[3], | |
| data[4], data[5], data[6], data[7], | |
| data[8], data[9], data[10], data[11], | |
| data[12], data[13], data[14], data[15] | |
| ); | |
| } | |
| function getConvertedIndex( index ) { | |
| if ( index > -1 && index < 3 ) { | |
| var members = [ 'X', 'Y', 'Z' ], | |
| indices = { X: 0, Y: 1, Z: 2 }; | |
| index = getConvertedMember( members[ index ] ); | |
| index = indices[ index ]; | |
| } | |
| return index; | |
| } | |
| function getConvertedMember( member ) { | |
| if ( options.convertUpAxis ) { | |
| switch ( member ) { | |
| case 'X': | |
| switch ( upConversion ) { | |
| case 'XtoY': | |
| case 'XtoZ': | |
| case 'YtoX': | |
| member = 'Y'; | |
| break; | |
| case 'ZtoX': | |
| member = 'Z'; | |
| break; | |
| } | |
| break; | |
| case 'Y': | |
| switch ( upConversion ) { | |
| case 'XtoY': | |
| case 'YtoX': | |
| case 'ZtoX': | |
| member = 'X'; | |
| break; | |
| case 'XtoZ': | |
| case 'YtoZ': | |
| case 'ZtoY': | |
| member = 'Z'; | |
| break; | |
| } | |
| break; | |
| case 'Z': | |
| switch ( upConversion ) { | |
| case 'XtoZ': | |
| member = 'X'; | |
| break; | |
| case 'YtoZ': | |
| case 'ZtoX': | |
| case 'ZtoY': | |
| member = 'Y'; | |
| break; | |
| } | |
| break; | |
| } | |
| } | |
| return member; | |
| } | |
| return { | |
| load: load, | |
| parse: parse, | |
| setPreferredShading: setPreferredShading, | |
| applySkin: applySkin, | |
| geometries : geometries, | |
| options: options | |
| }; | |
| }; | |
| },{}],19:[function(_dereq_,module,exports){ | |
| /** | |
| * Loads a Wavefront .mtl file specifying materials | |
| * | |
| * @author angelxuanchang | |
| */ | |
| THREE.MTLLoader = function( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| }; | |
| THREE.MTLLoader.prototype = { | |
| constructor: THREE.MTLLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var loader = new THREE.XHRLoader( this.manager ); | |
| loader.setPath( this.path ); | |
| loader.load( url, function ( text ) { | |
| onLoad( scope.parse( text ) ); | |
| }, onProgress, onError ); | |
| }, | |
| setPath: function ( value ) { | |
| this.path = value; | |
| }, | |
| setBaseUrl: function( value ) { | |
| // TODO: Merge with setPath()? Or rename to setTexturePath? | |
| this.baseUrl = value; | |
| }, | |
| setCrossOrigin: function ( value ) { | |
| this.crossOrigin = value; | |
| }, | |
| setMaterialOptions: function ( value ) { | |
| this.materialOptions = value; | |
| }, | |
| /** | |
| * Parses loaded MTL file | |
| * @param text - Content of MTL file | |
| * @return {THREE.MTLLoader.MaterialCreator} | |
| */ | |
| parse: function ( text ) { | |
| var lines = text.split( "\n" ); | |
| var info = {}; | |
| var delimiter_pattern = /\s+/; | |
| var materialsInfo = {}; | |
| for ( var i = 0; i < lines.length; i ++ ) { | |
| var line = lines[ i ]; | |
| line = line.trim(); | |
| if ( line.length === 0 || line.charAt( 0 ) === '#' ) { | |
| // Blank line or comment ignore | |
| continue; | |
| } | |
| var pos = line.indexOf( ' ' ); | |
| var key = ( pos >= 0 ) ? line.substring( 0, pos ) : line; | |
| key = key.toLowerCase(); | |
| var value = ( pos >= 0 ) ? line.substring( pos + 1 ) : ""; | |
| value = value.trim(); | |
| if ( key === "newmtl" ) { | |
| // New material | |
| info = { name: value }; | |
| materialsInfo[ value ] = info; | |
| } else if ( info ) { | |
| if ( key === "ka" || key === "kd" || key === "ks" ) { | |
| var ss = value.split( delimiter_pattern, 3 ); | |
| info[ key ] = [ parseFloat( ss[ 0 ] ), parseFloat( ss[ 1 ] ), parseFloat( ss[ 2 ] ) ]; | |
| } else { | |
| info[ key ] = value; | |
| } | |
| } | |
| } | |
| var materialCreator = new THREE.MTLLoader.MaterialCreator( this.baseUrl, this.materialOptions ); | |
| materialCreator.setCrossOrigin( this.crossOrigin ); | |
| materialCreator.setManager( this.manager ); | |
| materialCreator.setMaterials( materialsInfo ); | |
| return materialCreator; | |
| } | |
| }; | |
| /** | |
| * Create a new THREE-MTLLoader.MaterialCreator | |
| * @param baseUrl - Url relative to which textures are loaded | |
| * @param options - Set of options on how to construct the materials | |
| * side: Which side to apply the material | |
| * THREE.FrontSide (default), THREE.BackSide, THREE.DoubleSide | |
| * wrap: What type of wrapping to apply for textures | |
| * THREE.RepeatWrapping (default), THREE.ClampToEdgeWrapping, THREE.MirroredRepeatWrapping | |
| * normalizeRGB: RGBs need to be normalized to 0-1 from 0-255 | |
| * Default: false, assumed to be already normalized | |
| * ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's | |
| * Default: false | |
| * @constructor | |
| */ | |
| THREE.MTLLoader.MaterialCreator = function( baseUrl, options ) { | |
| this.baseUrl = baseUrl; | |
| this.options = options; | |
| this.materialsInfo = {}; | |
| this.materials = {}; | |
| this.materialsArray = []; | |
| this.nameLookup = {}; | |
| this.side = ( this.options && this.options.side ) ? this.options.side : THREE.FrontSide; | |
| this.wrap = ( this.options && this.options.wrap ) ? this.options.wrap : THREE.RepeatWrapping; | |
| }; | |
| THREE.MTLLoader.MaterialCreator.prototype = { | |
| constructor: THREE.MTLLoader.MaterialCreator, | |
| setCrossOrigin: function ( value ) { | |
| this.crossOrigin = value; | |
| }, | |
| setManager: function ( value ) { | |
| this.manager = value; | |
| }, | |
| setMaterials: function( materialsInfo ) { | |
| this.materialsInfo = this.convert( materialsInfo ); | |
| this.materials = {}; | |
| this.materialsArray = []; | |
| this.nameLookup = {}; | |
| }, | |
| convert: function( materialsInfo ) { | |
| if ( ! this.options ) return materialsInfo; | |
| var converted = {}; | |
| for ( var mn in materialsInfo ) { | |
| // Convert materials info into normalized form based on options | |
| var mat = materialsInfo[ mn ]; | |
| var covmat = {}; | |
| converted[ mn ] = covmat; | |
| for ( var prop in mat ) { | |
| var save = true; | |
| var value = mat[ prop ]; | |
| var lprop = prop.toLowerCase(); | |
| switch ( lprop ) { | |
| case 'kd': | |
| case 'ka': | |
| case 'ks': | |
| // Diffuse color (color under white light) using RGB values | |
| if ( this.options && this.options.normalizeRGB ) { | |
| value = [ value[ 0 ] / 255, value[ 1 ] / 255, value[ 2 ] / 255 ]; | |
| } | |
| if ( this.options && this.options.ignoreZeroRGBs ) { | |
| if ( value[ 0 ] === 0 && value[ 1 ] === 0 && value[ 1 ] === 0 ) { | |
| // ignore | |
| save = false; | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| if ( save ) { | |
| covmat[ lprop ] = value; | |
| } | |
| } | |
| } | |
| return converted; | |
| }, | |
| preload: function () { | |
| for ( var mn in this.materialsInfo ) { | |
| this.create( mn ); | |
| } | |
| }, | |
| getIndex: function( materialName ) { | |
| return this.nameLookup[ materialName ]; | |
| }, | |
| getAsArray: function() { | |
| var index = 0; | |
| for ( var mn in this.materialsInfo ) { | |
| this.materialsArray[ index ] = this.create( mn ); | |
| this.nameLookup[ mn ] = index; | |
| index ++; | |
| } | |
| return this.materialsArray; | |
| }, | |
| create: function ( materialName ) { | |
| if ( this.materials[ materialName ] === undefined ) { | |
| this.createMaterial_( materialName ); | |
| } | |
| return this.materials[ materialName ]; | |
| }, | |
| createMaterial_: function ( materialName ) { | |
| // Create material | |
| var mat = this.materialsInfo[ materialName ]; | |
| var params = { | |
| name: materialName, | |
| side: this.side | |
| }; | |
| for ( var prop in mat ) { | |
| var value = mat[ prop ]; | |
| if ( value === '' ) { | |
| continue; | |
| } | |
| switch ( prop.toLowerCase() ) { | |
| // Ns is material specular exponent | |
| case 'kd': | |
| // Diffuse color (color under white light) using RGB values | |
| params[ 'color' ] = new THREE.Color().fromArray( value ); | |
| break; | |
| case 'ks': | |
| // Specular color (color when light is reflected from shiny surface) using RGB values | |
| params[ 'specular' ] = new THREE.Color().fromArray( value ); | |
| break; | |
| case 'map_kd': | |
| // Diffuse texture map | |
| params[ 'map' ] = this.loadTexture( this.baseUrl + value ); | |
| params[ 'map' ].wrapS = this.wrap; | |
| params[ 'map' ].wrapT = this.wrap; | |
| break; | |
| case 'ns': | |
| // The specular exponent (defines the focus of the specular highlight) | |
| // A high exponent results in a tight, concentrated highlight. Ns values normally range from 0 to 1000. | |
| params[ 'shininess' ] = parseFloat( value ); | |
| break; | |
| case 'd': | |
| if ( value < 1 ) { | |
| params[ 'opacity' ] = value; | |
| params[ 'transparent' ] = true; | |
| } | |
| break; | |
| case 'Tr': | |
| if ( value > 0 ) { | |
| params[ 'opacity' ] = 1 - value; | |
| params[ 'transparent' ] = true; | |
| } | |
| break; | |
| case 'map_bump': | |
| case 'bump': | |
| // Bump texture map | |
| if ( params[ 'bumpMap' ] ) break; // Avoid loading twice. | |
| params[ 'bumpMap' ] = this.loadTexture( this.baseUrl + value ); | |
| params[ 'bumpMap' ].wrapS = this.wrap; | |
| params[ 'bumpMap' ].wrapT = this.wrap; | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| this.materials[ materialName ] = new THREE.MeshPhongMaterial( params ); | |
| return this.materials[ materialName ]; | |
| }, | |
| loadTexture: function ( url, mapping, onLoad, onProgress, onError ) { | |
| var texture; | |
| var loader = THREE.Loader.Handlers.get( url ); | |
| var manager = ( this.manager !== undefined ) ? this.manager : THREE.DefaultLoadingManager; | |
| if ( loader === null ) { | |
| loader = new THREE.TextureLoader( manager ); | |
| } | |
| if ( loader.setCrossOrigin ) loader.setCrossOrigin( this.crossOrigin ); | |
| texture = loader.load( url, onLoad, onProgress, onError ); | |
| if ( mapping !== undefined ) texture.mapping = mapping; | |
| return texture; | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.MTLLoader.prototype ); | |
| },{}],20:[function(_dereq_,module,exports){ | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.OBJLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| this.materials = null; | |
| }; | |
| THREE.OBJLoader.prototype = { | |
| constructor: THREE.OBJLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var loader = new THREE.XHRLoader( scope.manager ); | |
| loader.setPath( this.path ); | |
| loader.load( url, function ( text ) { | |
| onLoad( scope.parse( text ) ); | |
| }, onProgress, onError ); | |
| }, | |
| setPath: function ( value ) { | |
| this.path = value; | |
| }, | |
| setMaterials: function ( materials ) { | |
| this.materials = materials; | |
| }, | |
| parse: function ( text ) { | |
| console.time( 'OBJLoader' ); | |
| var objects = []; | |
| var object; | |
| var foundObjects = false; | |
| var vertices = []; | |
| var normals = []; | |
| var uvs = []; | |
| function addObject( name ) { | |
| var geometry = { | |
| vertices: [], | |
| normals: [], | |
| uvs: [] | |
| }; | |
| var material = { | |
| name: '', | |
| smooth: true | |
| }; | |
| object = { | |
| name: name, | |
| geometry: geometry, | |
| material: material | |
| }; | |
| objects.push( object ); | |
| } | |
| function parseVertexIndex( value ) { | |
| var index = parseInt( value ); | |
| return ( index >= 0 ? index - 1 : index + vertices.length / 3 ) * 3; | |
| } | |
| function parseNormalIndex( value ) { | |
| var index = parseInt( value ); | |
| return ( index >= 0 ? index - 1 : index + normals.length / 3 ) * 3; | |
| } | |
| function parseUVIndex( value ) { | |
| var index = parseInt( value ); | |
| return ( index >= 0 ? index - 1 : index + uvs.length / 2 ) * 2; | |
| } | |
| function addVertex( a, b, c ) { | |
| object.geometry.vertices.push( | |
| vertices[ a ], vertices[ a + 1 ], vertices[ a + 2 ], | |
| vertices[ b ], vertices[ b + 1 ], vertices[ b + 2 ], | |
| vertices[ c ], vertices[ c + 1 ], vertices[ c + 2 ] | |
| ); | |
| } | |
| function addNormal( a, b, c ) { | |
| object.geometry.normals.push( | |
| normals[ a ], normals[ a + 1 ], normals[ a + 2 ], | |
| normals[ b ], normals[ b + 1 ], normals[ b + 2 ], | |
| normals[ c ], normals[ c + 1 ], normals[ c + 2 ] | |
| ); | |
| } | |
| function addUV( a, b, c ) { | |
| object.geometry.uvs.push( | |
| uvs[ a ], uvs[ a + 1 ], | |
| uvs[ b ], uvs[ b + 1 ], | |
| uvs[ c ], uvs[ c + 1 ] | |
| ); | |
| } | |
| function addFace( a, b, c, d, ua, ub, uc, ud, na, nb, nc, nd ) { | |
| var ia = parseVertexIndex( a ); | |
| var ib = parseVertexIndex( b ); | |
| var ic = parseVertexIndex( c ); | |
| var id; | |
| if ( d === undefined ) { | |
| addVertex( ia, ib, ic ); | |
| } else { | |
| id = parseVertexIndex( d ); | |
| addVertex( ia, ib, id ); | |
| addVertex( ib, ic, id ); | |
| } | |
| if ( ua !== undefined ) { | |
| ia = parseUVIndex( ua ); | |
| ib = parseUVIndex( ub ); | |
| ic = parseUVIndex( uc ); | |
| if ( d === undefined ) { | |
| addUV( ia, ib, ic ); | |
| } else { | |
| id = parseUVIndex( ud ); | |
| addUV( ia, ib, id ); | |
| addUV( ib, ic, id ); | |
| } | |
| } | |
| if ( na !== undefined ) { | |
| ia = parseNormalIndex( na ); | |
| ib = parseNormalIndex( nb ); | |
| ic = parseNormalIndex( nc ); | |
| if ( d === undefined ) { | |
| addNormal( ia, ib, ic ); | |
| } else { | |
| id = parseNormalIndex( nd ); | |
| addNormal( ia, ib, id ); | |
| addNormal( ib, ic, id ); | |
| } | |
| } | |
| } | |
| addObject( '' ); | |
| // v float float float | |
| var vertex_pattern = /^v\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/; | |
| // vn float float float | |
| var normal_pattern = /^vn\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/; | |
| // vt float float | |
| var uv_pattern = /^vt\s+([\d|\.|\+|\-|e|E]+)\s+([\d|\.|\+|\-|e|E]+)/; | |
| // f vertex vertex vertex ... | |
| var face_pattern1 = /^f\s+(-?\d+)\s+(-?\d+)\s+(-?\d+)(?:\s+(-?\d+))?/; | |
| // f vertex/uv vertex/uv vertex/uv ... | |
| var face_pattern2 = /^f\s+((-?\d+)\/(-?\d+))\s+((-?\d+)\/(-?\d+))\s+((-?\d+)\/(-?\d+))(?:\s+((-?\d+)\/(-?\d+)))?/; | |
| // f vertex/uv/normal vertex/uv/normal vertex/uv/normal ... | |
| var face_pattern3 = /^f\s+((-?\d+)\/(-?\d+)\/(-?\d+))\s+((-?\d+)\/(-?\d+)\/(-?\d+))\s+((-?\d+)\/(-?\d+)\/(-?\d+))(?:\s+((-?\d+)\/(-?\d+)\/(-?\d+)))?/; | |
| // f vertex//normal vertex//normal vertex//normal ... | |
| var face_pattern4 = /^f\s+((-?\d+)\/\/(-?\d+))\s+((-?\d+)\/\/(-?\d+))\s+((-?\d+)\/\/(-?\d+))(?:\s+((-?\d+)\/\/(-?\d+)))?/; | |
| var object_pattern = /^[og]\s+(.+)/; | |
| var smoothing_pattern = /^s\s+([01]|on|off)/; | |
| // | |
| var lines = text.split( '\n' ); | |
| for ( var i = 0; i < lines.length; i ++ ) { | |
| var line = lines[ i ]; | |
| line = line.trim(); | |
| var result; | |
| if ( line.length === 0 || line.charAt( 0 ) === '#' ) { | |
| continue; | |
| } else if ( ( result = vertex_pattern.exec( line ) ) !== null ) { | |
| // ["v 1.0 2.0 3.0", "1.0", "2.0", "3.0"] | |
| vertices.push( | |
| parseFloat( result[ 1 ] ), | |
| parseFloat( result[ 2 ] ), | |
| parseFloat( result[ 3 ] ) | |
| ); | |
| } else if ( ( result = normal_pattern.exec( line ) ) !== null ) { | |
| // ["vn 1.0 2.0 3.0", "1.0", "2.0", "3.0"] | |
| normals.push( | |
| parseFloat( result[ 1 ] ), | |
| parseFloat( result[ 2 ] ), | |
| parseFloat( result[ 3 ] ) | |
| ); | |
| } else if ( ( result = uv_pattern.exec( line ) ) !== null ) { | |
| // ["vt 0.1 0.2", "0.1", "0.2"] | |
| uvs.push( | |
| parseFloat( result[ 1 ] ), | |
| parseFloat( result[ 2 ] ) | |
| ); | |
| } else if ( ( result = face_pattern1.exec( line ) ) !== null ) { | |
| // ["f 1 2 3", "1", "2", "3", undefined] | |
| addFace( | |
| result[ 1 ], result[ 2 ], result[ 3 ], result[ 4 ] | |
| ); | |
| } else if ( ( result = face_pattern2.exec( line ) ) !== null ) { | |
| // ["f 1/1 2/2 3/3", " 1/1", "1", "1", " 2/2", "2", "2", " 3/3", "3", "3", undefined, undefined, undefined] | |
| addFace( | |
| result[ 2 ], result[ 5 ], result[ 8 ], result[ 11 ], | |
| result[ 3 ], result[ 6 ], result[ 9 ], result[ 12 ] | |
| ); | |
| } else if ( ( result = face_pattern3.exec( line ) ) !== null ) { | |
| // ["f 1/1/1 2/2/2 3/3/3", " 1/1/1", "1", "1", "1", " 2/2/2", "2", "2", "2", " 3/3/3", "3", "3", "3", undefined, undefined, undefined, undefined] | |
| addFace( | |
| result[ 2 ], result[ 6 ], result[ 10 ], result[ 14 ], | |
| result[ 3 ], result[ 7 ], result[ 11 ], result[ 15 ], | |
| result[ 4 ], result[ 8 ], result[ 12 ], result[ 16 ] | |
| ); | |
| } else if ( ( result = face_pattern4.exec( line ) ) !== null ) { | |
| // ["f 1//1 2//2 3//3", " 1//1", "1", "1", " 2//2", "2", "2", " 3//3", "3", "3", undefined, undefined, undefined] | |
| addFace( | |
| result[ 2 ], result[ 5 ], result[ 8 ], result[ 11 ], | |
| undefined, undefined, undefined, undefined, | |
| result[ 3 ], result[ 6 ], result[ 9 ], result[ 12 ] | |
| ); | |
| } else if ( ( result = object_pattern.exec( line ) ) !== null ) { | |
| // o object_name | |
| // or | |
| // g group_name | |
| var name = result[ 1 ].trim(); | |
| if ( foundObjects === false ) { | |
| foundObjects = true; | |
| object.name = name; | |
| } else { | |
| addObject( name ); | |
| } | |
| } else if ( /^usemtl /.test( line ) ) { | |
| // material | |
| object.material.name = line.substring( 7 ).trim(); | |
| } else if ( /^mtllib /.test( line ) ) { | |
| // mtl file | |
| } else if ( ( result = smoothing_pattern.exec( line ) ) !== null ) { | |
| // smooth shading | |
| object.material.smooth = result[ 1 ] === "1" || result[ 1 ] === "on"; | |
| } else { | |
| throw new Error( "Unexpected line: " + line ); | |
| } | |
| } | |
| var container = new THREE.Group(); | |
| for ( var i = 0, l = objects.length; i < l; i ++ ) { | |
| object = objects[ i ]; | |
| var geometry = object.geometry; | |
| var buffergeometry = new THREE.BufferGeometry(); | |
| buffergeometry.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( geometry.vertices ), 3 ) ); | |
| if ( geometry.normals.length > 0 ) { | |
| buffergeometry.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( geometry.normals ), 3 ) ); | |
| } else { | |
| buffergeometry.computeVertexNormals(); | |
| } | |
| if ( geometry.uvs.length > 0 ) { | |
| buffergeometry.addAttribute( 'uv', new THREE.BufferAttribute( new Float32Array( geometry.uvs ), 2 ) ); | |
| } | |
| var material; | |
| if ( this.materials !== null ) { | |
| material = this.materials.create( object.material.name ); | |
| } | |
| if ( !material ) { | |
| material = new THREE.MeshPhongMaterial(); | |
| material.name = object.material.name; | |
| } | |
| material.shading = object.material.smooth ? THREE.SmoothShading : THREE.FlatShading; | |
| var mesh = new THREE.Mesh( buffergeometry, material ); | |
| mesh.name = object.name; | |
| container.add( mesh ); | |
| } | |
| console.timeEnd( 'OBJLoader' ); | |
| return container; | |
| } | |
| }; | |
| },{}],21:[function(_dereq_,module,exports){ | |
| var self = self || {};// File:src/Three.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| var THREE = { REVISION: '74' }; | |
| // | |
| if ( typeof define === 'function' && define.amd ) { | |
| define( 'three', THREE ); | |
| } else if ( 'undefined' !== typeof exports && 'undefined' !== typeof module ) { | |
| module.exports = THREE; | |
| } | |
| // | |
| if ( Number.EPSILON === undefined ) { | |
| Number.EPSILON = Math.pow( 2, - 52 ); | |
| } | |
| // | |
| if ( Math.sign === undefined ) { | |
| // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign | |
| Math.sign = function ( x ) { | |
| return ( x < 0 ) ? - 1 : ( x > 0 ) ? 1 : + x; | |
| }; | |
| } | |
| if ( Function.prototype.name === undefined && Object.defineProperty !== undefined ) { | |
| // Missing in IE9-11. | |
| // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name | |
| Object.defineProperty( Function.prototype, 'name', { | |
| get: function () { | |
| return this.toString().match( /^\s*function\s*(\S*)\s*\(/ )[ 1 ]; | |
| } | |
| } ); | |
| } | |
| if ( Object.assign === undefined ) { | |
| // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign | |
| Object.defineProperty( Object, 'assign', { | |
| writable: true, | |
| configurable: true, | |
| value: function ( target ) { | |
| 'use strict'; | |
| if ( target === undefined || target === null ) { | |
| throw new TypeError( "Cannot convert first argument to object" ); | |
| } | |
| var to = Object( target ); | |
| for ( var i = 1, n = arguments.length; i !== n; ++ i ) { | |
| var nextSource = arguments[ i ]; | |
| if ( nextSource === undefined || nextSource === null ) continue; | |
| nextSource = Object( nextSource ); | |
| var keysArray = Object.keys( nextSource ); | |
| for ( var nextIndex = 0, len = keysArray.length; nextIndex !== len; ++ nextIndex ) { | |
| var nextKey = keysArray[ nextIndex ]; | |
| var desc = Object.getOwnPropertyDescriptor( nextSource, nextKey ); | |
| if ( desc !== undefined && desc.enumerable ) { | |
| to[ nextKey ] = nextSource[ nextKey ]; | |
| } | |
| } | |
| } | |
| return to; | |
| } | |
| } ); | |
| } | |
| // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.button | |
| THREE.MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 }; | |
| // GL STATE CONSTANTS | |
| THREE.CullFaceNone = 0; | |
| THREE.CullFaceBack = 1; | |
| THREE.CullFaceFront = 2; | |
| THREE.CullFaceFrontBack = 3; | |
| THREE.FrontFaceDirectionCW = 0; | |
| THREE.FrontFaceDirectionCCW = 1; | |
| // SHADOWING TYPES | |
| THREE.BasicShadowMap = 0; | |
| THREE.PCFShadowMap = 1; | |
| THREE.PCFSoftShadowMap = 2; | |
| // MATERIAL CONSTANTS | |
| // side | |
| THREE.FrontSide = 0; | |
| THREE.BackSide = 1; | |
| THREE.DoubleSide = 2; | |
| // shading | |
| THREE.FlatShading = 1; | |
| THREE.SmoothShading = 2; | |
| // colors | |
| THREE.NoColors = 0; | |
| THREE.FaceColors = 1; | |
| THREE.VertexColors = 2; | |
| // blending modes | |
| THREE.NoBlending = 0; | |
| THREE.NormalBlending = 1; | |
| THREE.AdditiveBlending = 2; | |
| THREE.SubtractiveBlending = 3; | |
| THREE.MultiplyBlending = 4; | |
| THREE.CustomBlending = 5; | |
| // custom blending equations | |
| // (numbers start from 100 not to clash with other | |
| // mappings to OpenGL constants defined in Texture.js) | |
| THREE.AddEquation = 100; | |
| THREE.SubtractEquation = 101; | |
| THREE.ReverseSubtractEquation = 102; | |
| THREE.MinEquation = 103; | |
| THREE.MaxEquation = 104; | |
| // custom blending destination factors | |
| THREE.ZeroFactor = 200; | |
| THREE.OneFactor = 201; | |
| THREE.SrcColorFactor = 202; | |
| THREE.OneMinusSrcColorFactor = 203; | |
| THREE.SrcAlphaFactor = 204; | |
| THREE.OneMinusSrcAlphaFactor = 205; | |
| THREE.DstAlphaFactor = 206; | |
| THREE.OneMinusDstAlphaFactor = 207; | |
| // custom blending source factors | |
| //THREE.ZeroFactor = 200; | |
| //THREE.OneFactor = 201; | |
| //THREE.SrcAlphaFactor = 204; | |
| //THREE.OneMinusSrcAlphaFactor = 205; | |
| //THREE.DstAlphaFactor = 206; | |
| //THREE.OneMinusDstAlphaFactor = 207; | |
| THREE.DstColorFactor = 208; | |
| THREE.OneMinusDstColorFactor = 209; | |
| THREE.SrcAlphaSaturateFactor = 210; | |
| // depth modes | |
| THREE.NeverDepth = 0; | |
| THREE.AlwaysDepth = 1; | |
| THREE.LessDepth = 2; | |
| THREE.LessEqualDepth = 3; | |
| THREE.EqualDepth = 4; | |
| THREE.GreaterEqualDepth = 5; | |
| THREE.GreaterDepth = 6; | |
| THREE.NotEqualDepth = 7; | |
| // TEXTURE CONSTANTS | |
| THREE.MultiplyOperation = 0; | |
| THREE.MixOperation = 1; | |
| THREE.AddOperation = 2; | |
| // Mapping modes | |
| THREE.UVMapping = 300; | |
| THREE.CubeReflectionMapping = 301; | |
| THREE.CubeRefractionMapping = 302; | |
| THREE.EquirectangularReflectionMapping = 303; | |
| THREE.EquirectangularRefractionMapping = 304; | |
| THREE.SphericalReflectionMapping = 305; | |
| // Wrapping modes | |
| THREE.RepeatWrapping = 1000; | |
| THREE.ClampToEdgeWrapping = 1001; | |
| THREE.MirroredRepeatWrapping = 1002; | |
| // Filters | |
| THREE.NearestFilter = 1003; | |
| THREE.NearestMipMapNearestFilter = 1004; | |
| THREE.NearestMipMapLinearFilter = 1005; | |
| THREE.LinearFilter = 1006; | |
| THREE.LinearMipMapNearestFilter = 1007; | |
| THREE.LinearMipMapLinearFilter = 1008; | |
| // Data types | |
| THREE.UnsignedByteType = 1009; | |
| THREE.ByteType = 1010; | |
| THREE.ShortType = 1011; | |
| THREE.UnsignedShortType = 1012; | |
| THREE.IntType = 1013; | |
| THREE.UnsignedIntType = 1014; | |
| THREE.FloatType = 1015; | |
| THREE.HalfFloatType = 1025; | |
| // Pixel types | |
| //THREE.UnsignedByteType = 1009; | |
| THREE.UnsignedShort4444Type = 1016; | |
| THREE.UnsignedShort5551Type = 1017; | |
| THREE.UnsignedShort565Type = 1018; | |
| // Pixel formats | |
| THREE.AlphaFormat = 1019; | |
| THREE.RGBFormat = 1020; | |
| THREE.RGBAFormat = 1021; | |
| THREE.LuminanceFormat = 1022; | |
| THREE.LuminanceAlphaFormat = 1023; | |
| // THREE.RGBEFormat handled as THREE.RGBAFormat in shaders | |
| THREE.RGBEFormat = THREE.RGBAFormat; //1024; | |
| // DDS / ST3C Compressed texture formats | |
| THREE.RGB_S3TC_DXT1_Format = 2001; | |
| THREE.RGBA_S3TC_DXT1_Format = 2002; | |
| THREE.RGBA_S3TC_DXT3_Format = 2003; | |
| THREE.RGBA_S3TC_DXT5_Format = 2004; | |
| // PVRTC compressed texture formats | |
| THREE.RGB_PVRTC_4BPPV1_Format = 2100; | |
| THREE.RGB_PVRTC_2BPPV1_Format = 2101; | |
| THREE.RGBA_PVRTC_4BPPV1_Format = 2102; | |
| THREE.RGBA_PVRTC_2BPPV1_Format = 2103; | |
| // ETC compressed texture formats | |
| THREE.RGB_ETC1_Format = 2151; | |
| // Loop styles for AnimationAction | |
| THREE.LoopOnce = 2200; | |
| THREE.LoopRepeat = 2201; | |
| THREE.LoopPingPong = 2202; | |
| // Interpolation | |
| THREE.InterpolateDiscrete = 2300; | |
| THREE.InterpolateLinear = 2301; | |
| THREE.InterpolateSmooth = 2302; | |
| // Interpolant ending modes | |
| THREE.ZeroCurvatureEnding = 2400; | |
| THREE.ZeroSlopeEnding = 2401; | |
| THREE.WrapAroundEnding = 2402; | |
| // Triangle Draw modes | |
| THREE.TrianglesDrawMode = 0; | |
| THREE.TriangleStripDrawMode = 1; | |
| THREE.TriangleFanDrawMode = 2; | |
| // File:src/math/Color.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Color = function ( color ) { | |
| if ( arguments.length === 3 ) { | |
| return this.fromArray( arguments ); | |
| } | |
| return this.set( color ); | |
| }; | |
| THREE.Color.prototype = { | |
| constructor: THREE.Color, | |
| r: 1, g: 1, b: 1, | |
| set: function ( value ) { | |
| if ( value instanceof THREE.Color ) { | |
| this.copy( value ); | |
| } else if ( typeof value === 'number' ) { | |
| this.setHex( value ); | |
| } else if ( typeof value === 'string' ) { | |
| this.setStyle( value ); | |
| } | |
| return this; | |
| }, | |
| setScalar: function ( scalar ) { | |
| this.r = scalar; | |
| this.g = scalar; | |
| this.b = scalar; | |
| }, | |
| setHex: function ( hex ) { | |
| hex = Math.floor( hex ); | |
| this.r = ( hex >> 16 & 255 ) / 255; | |
| this.g = ( hex >> 8 & 255 ) / 255; | |
| this.b = ( hex & 255 ) / 255; | |
| return this; | |
| }, | |
| setRGB: function ( r, g, b ) { | |
| this.r = r; | |
| this.g = g; | |
| this.b = b; | |
| return this; | |
| }, | |
| setHSL: function () { | |
| function hue2rgb( p, q, t ) { | |
| if ( t < 0 ) t += 1; | |
| if ( t > 1 ) t -= 1; | |
| if ( t < 1 / 6 ) return p + ( q - p ) * 6 * t; | |
| if ( t < 1 / 2 ) return q; | |
| if ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t ); | |
| return p; | |
| } | |
| return function ( h, s, l ) { | |
| // h,s,l ranges are in 0.0 - 1.0 | |
| h = THREE.Math.euclideanModulo( h, 1 ); | |
| s = THREE.Math.clamp( s, 0, 1 ); | |
| l = THREE.Math.clamp( l, 0, 1 ); | |
| if ( s === 0 ) { | |
| this.r = this.g = this.b = l; | |
| } else { | |
| var p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s ); | |
| var q = ( 2 * l ) - p; | |
| this.r = hue2rgb( q, p, h + 1 / 3 ); | |
| this.g = hue2rgb( q, p, h ); | |
| this.b = hue2rgb( q, p, h - 1 / 3 ); | |
| } | |
| return this; | |
| }; | |
| }(), | |
| setStyle: function ( style ) { | |
| function handleAlpha( string ) { | |
| if ( string === undefined ) return; | |
| if ( parseFloat( string ) < 1 ) { | |
| console.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' ); | |
| } | |
| } | |
| var m; | |
| if ( m = /^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec( style ) ) { | |
| // rgb / hsl | |
| var color; | |
| var name = m[ 1 ]; | |
| var components = m[ 2 ]; | |
| switch ( name ) { | |
| case 'rgb': | |
| case 'rgba': | |
| if ( color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) { | |
| // rgb(255,0,0) rgba(255,0,0,0.5) | |
| this.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255; | |
| this.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255; | |
| this.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255; | |
| handleAlpha( color[ 5 ] ); | |
| return this; | |
| } | |
| if ( color = /^(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) { | |
| // rgb(100%,0%,0%) rgba(100%,0%,0%,0.5) | |
| this.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100; | |
| this.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100; | |
| this.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100; | |
| handleAlpha( color[ 5 ] ); | |
| return this; | |
| } | |
| break; | |
| case 'hsl': | |
| case 'hsla': | |
| if ( color = /^([0-9]*\.?[0-9]+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) { | |
| // hsl(120,50%,50%) hsla(120,50%,50%,0.5) | |
| var h = parseFloat( color[ 1 ] ) / 360; | |
| var s = parseInt( color[ 2 ], 10 ) / 100; | |
| var l = parseInt( color[ 3 ], 10 ) / 100; | |
| handleAlpha( color[ 5 ] ); | |
| return this.setHSL( h, s, l ); | |
| } | |
| break; | |
| } | |
| } else if ( m = /^\#([A-Fa-f0-9]+)$/.exec( style ) ) { | |
| // hex color | |
| var hex = m[ 1 ]; | |
| var size = hex.length; | |
| if ( size === 3 ) { | |
| // #ff0 | |
| this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255; | |
| this.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255; | |
| this.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255; | |
| return this; | |
| } else if ( size === 6 ) { | |
| // #ff0000 | |
| this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255; | |
| this.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255; | |
| this.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255; | |
| return this; | |
| } | |
| } | |
| if ( style && style.length > 0 ) { | |
| // color keywords | |
| var hex = THREE.ColorKeywords[ style ]; | |
| if ( hex !== undefined ) { | |
| // red | |
| this.setHex( hex ); | |
| } else { | |
| // unknown color | |
| console.warn( 'THREE.Color: Unknown color ' + style ); | |
| } | |
| } | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor( this.r, this.g, this.b ); | |
| }, | |
| copy: function ( color ) { | |
| this.r = color.r; | |
| this.g = color.g; | |
| this.b = color.b; | |
| return this; | |
| }, | |
| copyGammaToLinear: function ( color, gammaFactor ) { | |
| if ( gammaFactor === undefined ) gammaFactor = 2.0; | |
| this.r = Math.pow( color.r, gammaFactor ); | |
| this.g = Math.pow( color.g, gammaFactor ); | |
| this.b = Math.pow( color.b, gammaFactor ); | |
| return this; | |
| }, | |
| copyLinearToGamma: function ( color, gammaFactor ) { | |
| if ( gammaFactor === undefined ) gammaFactor = 2.0; | |
| var safeInverse = ( gammaFactor > 0 ) ? ( 1.0 / gammaFactor ) : 1.0; | |
| this.r = Math.pow( color.r, safeInverse ); | |
| this.g = Math.pow( color.g, safeInverse ); | |
| this.b = Math.pow( color.b, safeInverse ); | |
| return this; | |
| }, | |
| convertGammaToLinear: function () { | |
| var r = this.r, g = this.g, b = this.b; | |
| this.r = r * r; | |
| this.g = g * g; | |
| this.b = b * b; | |
| return this; | |
| }, | |
| convertLinearToGamma: function () { | |
| this.r = Math.sqrt( this.r ); | |
| this.g = Math.sqrt( this.g ); | |
| this.b = Math.sqrt( this.b ); | |
| return this; | |
| }, | |
| getHex: function () { | |
| return ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0; | |
| }, | |
| getHexString: function () { | |
| return ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 ); | |
| }, | |
| getHSL: function ( optionalTarget ) { | |
| // h,s,l ranges are in 0.0 - 1.0 | |
| var hsl = optionalTarget || { h: 0, s: 0, l: 0 }; | |
| var r = this.r, g = this.g, b = this.b; | |
| var max = Math.max( r, g, b ); | |
| var min = Math.min( r, g, b ); | |
| var hue, saturation; | |
| var lightness = ( min + max ) / 2.0; | |
| if ( min === max ) { | |
| hue = 0; | |
| saturation = 0; | |
| } else { | |
| var delta = max - min; | |
| saturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min ); | |
| switch ( max ) { | |
| case r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break; | |
| case g: hue = ( b - r ) / delta + 2; break; | |
| case b: hue = ( r - g ) / delta + 4; break; | |
| } | |
| hue /= 6; | |
| } | |
| hsl.h = hue; | |
| hsl.s = saturation; | |
| hsl.l = lightness; | |
| return hsl; | |
| }, | |
| getStyle: function () { | |
| return 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')'; | |
| }, | |
| offsetHSL: function ( h, s, l ) { | |
| var hsl = this.getHSL(); | |
| hsl.h += h; hsl.s += s; hsl.l += l; | |
| this.setHSL( hsl.h, hsl.s, hsl.l ); | |
| return this; | |
| }, | |
| add: function ( color ) { | |
| this.r += color.r; | |
| this.g += color.g; | |
| this.b += color.b; | |
| return this; | |
| }, | |
| addColors: function ( color1, color2 ) { | |
| this.r = color1.r + color2.r; | |
| this.g = color1.g + color2.g; | |
| this.b = color1.b + color2.b; | |
| return this; | |
| }, | |
| addScalar: function ( s ) { | |
| this.r += s; | |
| this.g += s; | |
| this.b += s; | |
| return this; | |
| }, | |
| multiply: function ( color ) { | |
| this.r *= color.r; | |
| this.g *= color.g; | |
| this.b *= color.b; | |
| return this; | |
| }, | |
| multiplyScalar: function ( s ) { | |
| this.r *= s; | |
| this.g *= s; | |
| this.b *= s; | |
| return this; | |
| }, | |
| lerp: function ( color, alpha ) { | |
| this.r += ( color.r - this.r ) * alpha; | |
| this.g += ( color.g - this.g ) * alpha; | |
| this.b += ( color.b - this.b ) * alpha; | |
| return this; | |
| }, | |
| equals: function ( c ) { | |
| return ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b ); | |
| }, | |
| fromArray: function ( array, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| this.r = array[ offset ]; | |
| this.g = array[ offset + 1 ]; | |
| this.b = array[ offset + 2 ]; | |
| return this; | |
| }, | |
| toArray: function ( array, offset ) { | |
| if ( array === undefined ) array = []; | |
| if ( offset === undefined ) offset = 0; | |
| array[ offset ] = this.r; | |
| array[ offset + 1 ] = this.g; | |
| array[ offset + 2 ] = this.b; | |
| return array; | |
| } | |
| }; | |
| THREE.ColorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF, | |
| 'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2, | |
| 'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50, | |
| 'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B, | |
| 'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B, | |
| 'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F, | |
| 'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3, | |
| 'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222, | |
| 'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700, | |
| 'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4, | |
| 'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00, | |
| 'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3, | |
| 'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA, | |
| 'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32, | |
| 'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3, | |
| 'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC, | |
| 'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD, | |
| 'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6, | |
| 'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9, | |
| 'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F, | |
| 'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE, | |
| 'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA, | |
| 'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0, | |
| 'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 }; | |
| // File:src/math/Quaternion.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author WestLangley / http://github.com/WestLangley | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Quaternion = function ( x, y, z, w ) { | |
| this._x = x || 0; | |
| this._y = y || 0; | |
| this._z = z || 0; | |
| this._w = ( w !== undefined ) ? w : 1; | |
| }; | |
| THREE.Quaternion.prototype = { | |
| constructor: THREE.Quaternion, | |
| get x () { | |
| return this._x; | |
| }, | |
| set x ( value ) { | |
| this._x = value; | |
| this.onChangeCallback(); | |
| }, | |
| get y () { | |
| return this._y; | |
| }, | |
| set y ( value ) { | |
| this._y = value; | |
| this.onChangeCallback(); | |
| }, | |
| get z () { | |
| return this._z; | |
| }, | |
| set z ( value ) { | |
| this._z = value; | |
| this.onChangeCallback(); | |
| }, | |
| get w () { | |
| return this._w; | |
| }, | |
| set w ( value ) { | |
| this._w = value; | |
| this.onChangeCallback(); | |
| }, | |
| set: function ( x, y, z, w ) { | |
| this._x = x; | |
| this._y = y; | |
| this._z = z; | |
| this._w = w; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor( this._x, this._y, this._z, this._w ); | |
| }, | |
| copy: function ( quaternion ) { | |
| this._x = quaternion.x; | |
| this._y = quaternion.y; | |
| this._z = quaternion.z; | |
| this._w = quaternion.w; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| setFromEuler: function ( euler, update ) { | |
| if ( euler instanceof THREE.Euler === false ) { | |
| throw new Error( 'THREE.Quaternion: .setFromEuler() now expects a Euler rotation rather than a Vector3 and order.' ); | |
| } | |
| // http://www.mathworks.com/matlabcentral/fileexchange/ | |
| // 20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/ | |
| // content/SpinCalc.m | |
| var c1 = Math.cos( euler._x / 2 ); | |
| var c2 = Math.cos( euler._y / 2 ); | |
| var c3 = Math.cos( euler._z / 2 ); | |
| var s1 = Math.sin( euler._x / 2 ); | |
| var s2 = Math.sin( euler._y / 2 ); | |
| var s3 = Math.sin( euler._z / 2 ); | |
| var order = euler.order; | |
| if ( order === 'XYZ' ) { | |
| this._x = s1 * c2 * c3 + c1 * s2 * s3; | |
| this._y = c1 * s2 * c3 - s1 * c2 * s3; | |
| this._z = c1 * c2 * s3 + s1 * s2 * c3; | |
| this._w = c1 * c2 * c3 - s1 * s2 * s3; | |
| } else if ( order === 'YXZ' ) { | |
| this._x = s1 * c2 * c3 + c1 * s2 * s3; | |
| this._y = c1 * s2 * c3 - s1 * c2 * s3; | |
| this._z = c1 * c2 * s3 - s1 * s2 * c3; | |
| this._w = c1 * c2 * c3 + s1 * s2 * s3; | |
| } else if ( order === 'ZXY' ) { | |
| this._x = s1 * c2 * c3 - c1 * s2 * s3; | |
| this._y = c1 * s2 * c3 + s1 * c2 * s3; | |
| this._z = c1 * c2 * s3 + s1 * s2 * c3; | |
| this._w = c1 * c2 * c3 - s1 * s2 * s3; | |
| } else if ( order === 'ZYX' ) { | |
| this._x = s1 * c2 * c3 - c1 * s2 * s3; | |
| this._y = c1 * s2 * c3 + s1 * c2 * s3; | |
| this._z = c1 * c2 * s3 - s1 * s2 * c3; | |
| this._w = c1 * c2 * c3 + s1 * s2 * s3; | |
| } else if ( order === 'YZX' ) { | |
| this._x = s1 * c2 * c3 + c1 * s2 * s3; | |
| this._y = c1 * s2 * c3 + s1 * c2 * s3; | |
| this._z = c1 * c2 * s3 - s1 * s2 * c3; | |
| this._w = c1 * c2 * c3 - s1 * s2 * s3; | |
| } else if ( order === 'XZY' ) { | |
| this._x = s1 * c2 * c3 - c1 * s2 * s3; | |
| this._y = c1 * s2 * c3 - s1 * c2 * s3; | |
| this._z = c1 * c2 * s3 + s1 * s2 * c3; | |
| this._w = c1 * c2 * c3 + s1 * s2 * s3; | |
| } | |
| if ( update !== false ) this.onChangeCallback(); | |
| return this; | |
| }, | |
| setFromAxisAngle: function ( axis, angle ) { | |
| // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm | |
| // assumes axis is normalized | |
| var halfAngle = angle / 2, s = Math.sin( halfAngle ); | |
| this._x = axis.x * s; | |
| this._y = axis.y * s; | |
| this._z = axis.z * s; | |
| this._w = Math.cos( halfAngle ); | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| setFromRotationMatrix: function ( m ) { | |
| // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm | |
| // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) | |
| var te = m.elements, | |
| m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ], | |
| m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ], | |
| m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ], | |
| trace = m11 + m22 + m33, | |
| s; | |
| if ( trace > 0 ) { | |
| s = 0.5 / Math.sqrt( trace + 1.0 ); | |
| this._w = 0.25 / s; | |
| this._x = ( m32 - m23 ) * s; | |
| this._y = ( m13 - m31 ) * s; | |
| this._z = ( m21 - m12 ) * s; | |
| } else if ( m11 > m22 && m11 > m33 ) { | |
| s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 ); | |
| this._w = ( m32 - m23 ) / s; | |
| this._x = 0.25 * s; | |
| this._y = ( m12 + m21 ) / s; | |
| this._z = ( m13 + m31 ) / s; | |
| } else if ( m22 > m33 ) { | |
| s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 ); | |
| this._w = ( m13 - m31 ) / s; | |
| this._x = ( m12 + m21 ) / s; | |
| this._y = 0.25 * s; | |
| this._z = ( m23 + m32 ) / s; | |
| } else { | |
| s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 ); | |
| this._w = ( m21 - m12 ) / s; | |
| this._x = ( m13 + m31 ) / s; | |
| this._y = ( m23 + m32 ) / s; | |
| this._z = 0.25 * s; | |
| } | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| setFromUnitVectors: function () { | |
| // http://lolengine.net/blog/2014/02/24/quaternion-from-two-vectors-final | |
| // assumes direction vectors vFrom and vTo are normalized | |
| var v1, r; | |
| var EPS = 0.000001; | |
| return function ( vFrom, vTo ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| r = vFrom.dot( vTo ) + 1; | |
| if ( r < EPS ) { | |
| r = 0; | |
| if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) { | |
| v1.set( - vFrom.y, vFrom.x, 0 ); | |
| } else { | |
| v1.set( 0, - vFrom.z, vFrom.y ); | |
| } | |
| } else { | |
| v1.crossVectors( vFrom, vTo ); | |
| } | |
| this._x = v1.x; | |
| this._y = v1.y; | |
| this._z = v1.z; | |
| this._w = r; | |
| this.normalize(); | |
| return this; | |
| }; | |
| }(), | |
| inverse: function () { | |
| this.conjugate().normalize(); | |
| return this; | |
| }, | |
| conjugate: function () { | |
| this._x *= - 1; | |
| this._y *= - 1; | |
| this._z *= - 1; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| dot: function ( v ) { | |
| return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w; | |
| }, | |
| lengthSq: function () { | |
| return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w; | |
| }, | |
| length: function () { | |
| return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w ); | |
| }, | |
| normalize: function () { | |
| var l = this.length(); | |
| if ( l === 0 ) { | |
| this._x = 0; | |
| this._y = 0; | |
| this._z = 0; | |
| this._w = 1; | |
| } else { | |
| l = 1 / l; | |
| this._x = this._x * l; | |
| this._y = this._y * l; | |
| this._z = this._z * l; | |
| this._w = this._w * l; | |
| } | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| multiply: function ( q, p ) { | |
| if ( p !== undefined ) { | |
| console.warn( 'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' ); | |
| return this.multiplyQuaternions( q, p ); | |
| } | |
| return this.multiplyQuaternions( this, q ); | |
| }, | |
| multiplyQuaternions: function ( a, b ) { | |
| // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm | |
| var qax = a._x, qay = a._y, qaz = a._z, qaw = a._w; | |
| var qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w; | |
| this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby; | |
| this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz; | |
| this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx; | |
| this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| slerp: function ( qb, t ) { | |
| if ( t === 0 ) return this; | |
| if ( t === 1 ) return this.copy( qb ); | |
| var x = this._x, y = this._y, z = this._z, w = this._w; | |
| // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/ | |
| var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z; | |
| if ( cosHalfTheta < 0 ) { | |
| this._w = - qb._w; | |
| this._x = - qb._x; | |
| this._y = - qb._y; | |
| this._z = - qb._z; | |
| cosHalfTheta = - cosHalfTheta; | |
| } else { | |
| this.copy( qb ); | |
| } | |
| if ( cosHalfTheta >= 1.0 ) { | |
| this._w = w; | |
| this._x = x; | |
| this._y = y; | |
| this._z = z; | |
| return this; | |
| } | |
| var sinHalfTheta = Math.sqrt( 1.0 - cosHalfTheta * cosHalfTheta ); | |
| if ( Math.abs( sinHalfTheta ) < 0.001 ) { | |
| this._w = 0.5 * ( w + this._w ); | |
| this._x = 0.5 * ( x + this._x ); | |
| this._y = 0.5 * ( y + this._y ); | |
| this._z = 0.5 * ( z + this._z ); | |
| return this; | |
| } | |
| var halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta ); | |
| var ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta, | |
| ratioB = Math.sin( t * halfTheta ) / sinHalfTheta; | |
| this._w = ( w * ratioA + this._w * ratioB ); | |
| this._x = ( x * ratioA + this._x * ratioB ); | |
| this._y = ( y * ratioA + this._y * ratioB ); | |
| this._z = ( z * ratioA + this._z * ratioB ); | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| equals: function ( quaternion ) { | |
| return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w ); | |
| }, | |
| fromArray: function ( array, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| this._x = array[ offset ]; | |
| this._y = array[ offset + 1 ]; | |
| this._z = array[ offset + 2 ]; | |
| this._w = array[ offset + 3 ]; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| toArray: function ( array, offset ) { | |
| if ( array === undefined ) array = []; | |
| if ( offset === undefined ) offset = 0; | |
| array[ offset ] = this._x; | |
| array[ offset + 1 ] = this._y; | |
| array[ offset + 2 ] = this._z; | |
| array[ offset + 3 ] = this._w; | |
| return array; | |
| }, | |
| onChange: function ( callback ) { | |
| this.onChangeCallback = callback; | |
| return this; | |
| }, | |
| onChangeCallback: function () {} | |
| }; | |
| Object.assign( THREE.Quaternion, { | |
| slerp: function( qa, qb, qm, t ) { | |
| return qm.copy( qa ).slerp( qb, t ); | |
| }, | |
| slerpFlat: function( | |
| dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) { | |
| // fuzz-free, array-based Quaternion SLERP operation | |
| var x0 = src0[ srcOffset0 + 0 ], | |
| y0 = src0[ srcOffset0 + 1 ], | |
| z0 = src0[ srcOffset0 + 2 ], | |
| w0 = src0[ srcOffset0 + 3 ], | |
| x1 = src1[ srcOffset1 + 0 ], | |
| y1 = src1[ srcOffset1 + 1 ], | |
| z1 = src1[ srcOffset1 + 2 ], | |
| w1 = src1[ srcOffset1 + 3 ]; | |
| if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) { | |
| var s = 1 - t, | |
| cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1, | |
| dir = ( cos >= 0 ? 1 : - 1 ), | |
| sqrSin = 1 - cos * cos; | |
| // Skip the Slerp for tiny steps to avoid numeric problems: | |
| if ( sqrSin > Number.EPSILON ) { | |
| var sin = Math.sqrt( sqrSin ), | |
| len = Math.atan2( sin, cos * dir ); | |
| s = Math.sin( s * len ) / sin; | |
| t = Math.sin( t * len ) / sin; | |
| } | |
| var tDir = t * dir; | |
| x0 = x0 * s + x1 * tDir; | |
| y0 = y0 * s + y1 * tDir; | |
| z0 = z0 * s + z1 * tDir; | |
| w0 = w0 * s + w1 * tDir; | |
| // Normalize in case we just did a lerp: | |
| if ( s === 1 - t ) { | |
| var f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 ); | |
| x0 *= f; | |
| y0 *= f; | |
| z0 *= f; | |
| w0 *= f; | |
| } | |
| } | |
| dst[ dstOffset ] = x0; | |
| dst[ dstOffset + 1 ] = y0; | |
| dst[ dstOffset + 2 ] = z0; | |
| dst[ dstOffset + 3 ] = w0; | |
| } | |
| } ); | |
| // File:src/math/Vector2.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author philogb / http://blog.thejit.org/ | |
| * @author egraether / http://egraether.com/ | |
| * @author zz85 / http://www.lab4games.net/zz85/blog | |
| */ | |
| THREE.Vector2 = function ( x, y ) { | |
| this.x = x || 0; | |
| this.y = y || 0; | |
| }; | |
| THREE.Vector2.prototype = { | |
| constructor: THREE.Vector2, | |
| get width() { | |
| return this.x; | |
| }, | |
| set width( value ) { | |
| this.x = value; | |
| }, | |
| get height() { | |
| return this.y; | |
| }, | |
| set height( value ) { | |
| this.y = value; | |
| }, | |
| // | |
| set: function ( x, y ) { | |
| this.x = x; | |
| this.y = y; | |
| return this; | |
| }, | |
| setScalar: function ( scalar ) { | |
| this.x = scalar; | |
| this.y = scalar; | |
| return this; | |
| }, | |
| setX: function ( x ) { | |
| this.x = x; | |
| return this; | |
| }, | |
| setY: function ( y ) { | |
| this.y = y; | |
| return this; | |
| }, | |
| setComponent: function ( index, value ) { | |
| switch ( index ) { | |
| case 0: this.x = value; break; | |
| case 1: this.y = value; break; | |
| default: throw new Error( 'index is out of range: ' + index ); | |
| } | |
| }, | |
| getComponent: function ( index ) { | |
| switch ( index ) { | |
| case 0: return this.x; | |
| case 1: return this.y; | |
| default: throw new Error( 'index is out of range: ' + index ); | |
| } | |
| }, | |
| clone: function () { | |
| return new this.constructor( this.x, this.y ); | |
| }, | |
| copy: function ( v ) { | |
| this.x = v.x; | |
| this.y = v.y; | |
| return this; | |
| }, | |
| add: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' ); | |
| return this.addVectors( v, w ); | |
| } | |
| this.x += v.x; | |
| this.y += v.y; | |
| return this; | |
| }, | |
| addScalar: function ( s ) { | |
| this.x += s; | |
| this.y += s; | |
| return this; | |
| }, | |
| addVectors: function ( a, b ) { | |
| this.x = a.x + b.x; | |
| this.y = a.y + b.y; | |
| return this; | |
| }, | |
| addScaledVector: function ( v, s ) { | |
| this.x += v.x * s; | |
| this.y += v.y * s; | |
| return this; | |
| }, | |
| sub: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' ); | |
| return this.subVectors( v, w ); | |
| } | |
| this.x -= v.x; | |
| this.y -= v.y; | |
| return this; | |
| }, | |
| subScalar: function ( s ) { | |
| this.x -= s; | |
| this.y -= s; | |
| return this; | |
| }, | |
| subVectors: function ( a, b ) { | |
| this.x = a.x - b.x; | |
| this.y = a.y - b.y; | |
| return this; | |
| }, | |
| multiply: function ( v ) { | |
| this.x *= v.x; | |
| this.y *= v.y; | |
| return this; | |
| }, | |
| multiplyScalar: function ( scalar ) { | |
| if ( isFinite( scalar ) ) { | |
| this.x *= scalar; | |
| this.y *= scalar; | |
| } else { | |
| this.x = 0; | |
| this.y = 0; | |
| } | |
| return this; | |
| }, | |
| divide: function ( v ) { | |
| this.x /= v.x; | |
| this.y /= v.y; | |
| return this; | |
| }, | |
| divideScalar: function ( scalar ) { | |
| return this.multiplyScalar( 1 / scalar ); | |
| }, | |
| min: function ( v ) { | |
| this.x = Math.min( this.x, v.x ); | |
| this.y = Math.min( this.y, v.y ); | |
| return this; | |
| }, | |
| max: function ( v ) { | |
| this.x = Math.max( this.x, v.x ); | |
| this.y = Math.max( this.y, v.y ); | |
| return this; | |
| }, | |
| clamp: function ( min, max ) { | |
| // This function assumes min < max, if this assumption isn't true it will not operate correctly | |
| this.x = Math.max( min.x, Math.min( max.x, this.x ) ); | |
| this.y = Math.max( min.y, Math.min( max.y, this.y ) ); | |
| return this; | |
| }, | |
| clampScalar: function () { | |
| var min, max; | |
| return function clampScalar( minVal, maxVal ) { | |
| if ( min === undefined ) { | |
| min = new THREE.Vector2(); | |
| max = new THREE.Vector2(); | |
| } | |
| min.set( minVal, minVal ); | |
| max.set( maxVal, maxVal ); | |
| return this.clamp( min, max ); | |
| }; | |
| }(), | |
| clampLength: function ( min, max ) { | |
| var length = this.length(); | |
| this.multiplyScalar( Math.max( min, Math.min( max, length ) ) / length ); | |
| return this; | |
| }, | |
| floor: function () { | |
| this.x = Math.floor( this.x ); | |
| this.y = Math.floor( this.y ); | |
| return this; | |
| }, | |
| ceil: function () { | |
| this.x = Math.ceil( this.x ); | |
| this.y = Math.ceil( this.y ); | |
| return this; | |
| }, | |
| round: function () { | |
| this.x = Math.round( this.x ); | |
| this.y = Math.round( this.y ); | |
| return this; | |
| }, | |
| roundToZero: function () { | |
| this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x ); | |
| this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y ); | |
| return this; | |
| }, | |
| negate: function () { | |
| this.x = - this.x; | |
| this.y = - this.y; | |
| return this; | |
| }, | |
| dot: function ( v ) { | |
| return this.x * v.x + this.y * v.y; | |
| }, | |
| lengthSq: function () { | |
| return this.x * this.x + this.y * this.y; | |
| }, | |
| length: function () { | |
| return Math.sqrt( this.x * this.x + this.y * this.y ); | |
| }, | |
| lengthManhattan: function() { | |
| return Math.abs( this.x ) + Math.abs( this.y ); | |
| }, | |
| normalize: function () { | |
| return this.divideScalar( this.length() ); | |
| }, | |
| angle: function () { | |
| // computes the angle in radians with respect to the positive x-axis | |
| var angle = Math.atan2( this.y, this.x ); | |
| if ( angle < 0 ) angle += 2 * Math.PI; | |
| return angle; | |
| }, | |
| distanceTo: function ( v ) { | |
| return Math.sqrt( this.distanceToSquared( v ) ); | |
| }, | |
| distanceToSquared: function ( v ) { | |
| var dx = this.x - v.x, dy = this.y - v.y; | |
| return dx * dx + dy * dy; | |
| }, | |
| setLength: function ( length ) { | |
| return this.multiplyScalar( length / this.length() ); | |
| }, | |
| lerp: function ( v, alpha ) { | |
| this.x += ( v.x - this.x ) * alpha; | |
| this.y += ( v.y - this.y ) * alpha; | |
| return this; | |
| }, | |
| lerpVectors: function ( v1, v2, alpha ) { | |
| this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 ); | |
| return this; | |
| }, | |
| equals: function ( v ) { | |
| return ( ( v.x === this.x ) && ( v.y === this.y ) ); | |
| }, | |
| fromArray: function ( array, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| this.x = array[ offset ]; | |
| this.y = array[ offset + 1 ]; | |
| return this; | |
| }, | |
| toArray: function ( array, offset ) { | |
| if ( array === undefined ) array = []; | |
| if ( offset === undefined ) offset = 0; | |
| array[ offset ] = this.x; | |
| array[ offset + 1 ] = this.y; | |
| return array; | |
| }, | |
| fromAttribute: function ( attribute, index, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| index = index * attribute.itemSize + offset; | |
| this.x = attribute.array[ index ]; | |
| this.y = attribute.array[ index + 1 ]; | |
| return this; | |
| }, | |
| rotateAround: function ( center, angle ) { | |
| var c = Math.cos( angle ), s = Math.sin( angle ); | |
| var x = this.x - center.x; | |
| var y = this.y - center.y; | |
| this.x = x * c - y * s + center.x; | |
| this.y = x * s + y * c + center.y; | |
| return this; | |
| } | |
| }; | |
| // File:src/math/Vector3.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author *kile / http://kile.stravaganza.org/ | |
| * @author philogb / http://blog.thejit.org/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author egraether / http://egraether.com/ | |
| * @author WestLangley / http://github.com/WestLangley | |
| */ | |
| THREE.Vector3 = function ( x, y, z ) { | |
| this.x = x || 0; | |
| this.y = y || 0; | |
| this.z = z || 0; | |
| }; | |
| THREE.Vector3.prototype = { | |
| constructor: THREE.Vector3, | |
| set: function ( x, y, z ) { | |
| this.x = x; | |
| this.y = y; | |
| this.z = z; | |
| return this; | |
| }, | |
| setScalar: function ( scalar ) { | |
| this.x = scalar; | |
| this.y = scalar; | |
| this.z = scalar; | |
| return this; | |
| }, | |
| setX: function ( x ) { | |
| this.x = x; | |
| return this; | |
| }, | |
| setY: function ( y ) { | |
| this.y = y; | |
| return this; | |
| }, | |
| setZ: function ( z ) { | |
| this.z = z; | |
| return this; | |
| }, | |
| setComponent: function ( index, value ) { | |
| switch ( index ) { | |
| case 0: this.x = value; break; | |
| case 1: this.y = value; break; | |
| case 2: this.z = value; break; | |
| default: throw new Error( 'index is out of range: ' + index ); | |
| } | |
| }, | |
| getComponent: function ( index ) { | |
| switch ( index ) { | |
| case 0: return this.x; | |
| case 1: return this.y; | |
| case 2: return this.z; | |
| default: throw new Error( 'index is out of range: ' + index ); | |
| } | |
| }, | |
| clone: function () { | |
| return new this.constructor( this.x, this.y, this.z ); | |
| }, | |
| copy: function ( v ) { | |
| this.x = v.x; | |
| this.y = v.y; | |
| this.z = v.z; | |
| return this; | |
| }, | |
| add: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' ); | |
| return this.addVectors( v, w ); | |
| } | |
| this.x += v.x; | |
| this.y += v.y; | |
| this.z += v.z; | |
| return this; | |
| }, | |
| addScalar: function ( s ) { | |
| this.x += s; | |
| this.y += s; | |
| this.z += s; | |
| return this; | |
| }, | |
| addVectors: function ( a, b ) { | |
| this.x = a.x + b.x; | |
| this.y = a.y + b.y; | |
| this.z = a.z + b.z; | |
| return this; | |
| }, | |
| addScaledVector: function ( v, s ) { | |
| this.x += v.x * s; | |
| this.y += v.y * s; | |
| this.z += v.z * s; | |
| return this; | |
| }, | |
| sub: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' ); | |
| return this.subVectors( v, w ); | |
| } | |
| this.x -= v.x; | |
| this.y -= v.y; | |
| this.z -= v.z; | |
| return this; | |
| }, | |
| subScalar: function ( s ) { | |
| this.x -= s; | |
| this.y -= s; | |
| this.z -= s; | |
| return this; | |
| }, | |
| subVectors: function ( a, b ) { | |
| this.x = a.x - b.x; | |
| this.y = a.y - b.y; | |
| this.z = a.z - b.z; | |
| return this; | |
| }, | |
| multiply: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' ); | |
| return this.multiplyVectors( v, w ); | |
| } | |
| this.x *= v.x; | |
| this.y *= v.y; | |
| this.z *= v.z; | |
| return this; | |
| }, | |
| multiplyScalar: function ( scalar ) { | |
| if ( isFinite( scalar ) ) { | |
| this.x *= scalar; | |
| this.y *= scalar; | |
| this.z *= scalar; | |
| } else { | |
| this.x = 0; | |
| this.y = 0; | |
| this.z = 0; | |
| } | |
| return this; | |
| }, | |
| multiplyVectors: function ( a, b ) { | |
| this.x = a.x * b.x; | |
| this.y = a.y * b.y; | |
| this.z = a.z * b.z; | |
| return this; | |
| }, | |
| applyEuler: function () { | |
| var quaternion; | |
| return function applyEuler( euler ) { | |
| if ( euler instanceof THREE.Euler === false ) { | |
| console.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' ); | |
| } | |
| if ( quaternion === undefined ) quaternion = new THREE.Quaternion(); | |
| this.applyQuaternion( quaternion.setFromEuler( euler ) ); | |
| return this; | |
| }; | |
| }(), | |
| applyAxisAngle: function () { | |
| var quaternion; | |
| return function applyAxisAngle( axis, angle ) { | |
| if ( quaternion === undefined ) quaternion = new THREE.Quaternion(); | |
| this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) ); | |
| return this; | |
| }; | |
| }(), | |
| applyMatrix3: function ( m ) { | |
| var x = this.x; | |
| var y = this.y; | |
| var z = this.z; | |
| var e = m.elements; | |
| this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z; | |
| this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z; | |
| this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z; | |
| return this; | |
| }, | |
| applyMatrix4: function ( m ) { | |
| // input: THREE.Matrix4 affine matrix | |
| var x = this.x, y = this.y, z = this.z; | |
| var e = m.elements; | |
| this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ]; | |
| this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ]; | |
| this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ]; | |
| return this; | |
| }, | |
| applyProjection: function ( m ) { | |
| // input: THREE.Matrix4 projection matrix | |
| var x = this.x, y = this.y, z = this.z; | |
| var e = m.elements; | |
| var d = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] ); // perspective divide | |
| this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * d; | |
| this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * d; | |
| this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * d; | |
| return this; | |
| }, | |
| applyQuaternion: function ( q ) { | |
| var x = this.x; | |
| var y = this.y; | |
| var z = this.z; | |
| var qx = q.x; | |
| var qy = q.y; | |
| var qz = q.z; | |
| var qw = q.w; | |
| // calculate quat * vector | |
| var ix = qw * x + qy * z - qz * y; | |
| var iy = qw * y + qz * x - qx * z; | |
| var iz = qw * z + qx * y - qy * x; | |
| var iw = - qx * x - qy * y - qz * z; | |
| // calculate result * inverse quat | |
| this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy; | |
| this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz; | |
| this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx; | |
| return this; | |
| }, | |
| project: function () { | |
| var matrix; | |
| return function project( camera ) { | |
| if ( matrix === undefined ) matrix = new THREE.Matrix4(); | |
| matrix.multiplyMatrices( camera.projectionMatrix, matrix.getInverse( camera.matrixWorld ) ); | |
| return this.applyProjection( matrix ); | |
| }; | |
| }(), | |
| unproject: function () { | |
| var matrix; | |
| return function unproject( camera ) { | |
| if ( matrix === undefined ) matrix = new THREE.Matrix4(); | |
| matrix.multiplyMatrices( camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) ); | |
| return this.applyProjection( matrix ); | |
| }; | |
| }(), | |
| transformDirection: function ( m ) { | |
| // input: THREE.Matrix4 affine matrix | |
| // vector interpreted as a direction | |
| var x = this.x, y = this.y, z = this.z; | |
| var e = m.elements; | |
| this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z; | |
| this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z; | |
| this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z; | |
| this.normalize(); | |
| return this; | |
| }, | |
| divide: function ( v ) { | |
| this.x /= v.x; | |
| this.y /= v.y; | |
| this.z /= v.z; | |
| return this; | |
| }, | |
| divideScalar: function ( scalar ) { | |
| return this.multiplyScalar( 1 / scalar ); | |
| }, | |
| min: function ( v ) { | |
| this.x = Math.min( this.x, v.x ); | |
| this.y = Math.min( this.y, v.y ); | |
| this.z = Math.min( this.z, v.z ); | |
| return this; | |
| }, | |
| max: function ( v ) { | |
| this.x = Math.max( this.x, v.x ); | |
| this.y = Math.max( this.y, v.y ); | |
| this.z = Math.max( this.z, v.z ); | |
| return this; | |
| }, | |
| clamp: function ( min, max ) { | |
| // This function assumes min < max, if this assumption isn't true it will not operate correctly | |
| this.x = Math.max( min.x, Math.min( max.x, this.x ) ); | |
| this.y = Math.max( min.y, Math.min( max.y, this.y ) ); | |
| this.z = Math.max( min.z, Math.min( max.z, this.z ) ); | |
| return this; | |
| }, | |
| clampScalar: function () { | |
| var min, max; | |
| return function clampScalar( minVal, maxVal ) { | |
| if ( min === undefined ) { | |
| min = new THREE.Vector3(); | |
| max = new THREE.Vector3(); | |
| } | |
| min.set( minVal, minVal, minVal ); | |
| max.set( maxVal, maxVal, maxVal ); | |
| return this.clamp( min, max ); | |
| }; | |
| }(), | |
| clampLength: function ( min, max ) { | |
| var length = this.length(); | |
| this.multiplyScalar( Math.max( min, Math.min( max, length ) ) / length ); | |
| return this; | |
| }, | |
| floor: function () { | |
| this.x = Math.floor( this.x ); | |
| this.y = Math.floor( this.y ); | |
| this.z = Math.floor( this.z ); | |
| return this; | |
| }, | |
| ceil: function () { | |
| this.x = Math.ceil( this.x ); | |
| this.y = Math.ceil( this.y ); | |
| this.z = Math.ceil( this.z ); | |
| return this; | |
| }, | |
| round: function () { | |
| this.x = Math.round( this.x ); | |
| this.y = Math.round( this.y ); | |
| this.z = Math.round( this.z ); | |
| return this; | |
| }, | |
| roundToZero: function () { | |
| this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x ); | |
| this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y ); | |
| this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z ); | |
| return this; | |
| }, | |
| negate: function () { | |
| this.x = - this.x; | |
| this.y = - this.y; | |
| this.z = - this.z; | |
| return this; | |
| }, | |
| dot: function ( v ) { | |
| return this.x * v.x + this.y * v.y + this.z * v.z; | |
| }, | |
| lengthSq: function () { | |
| return this.x * this.x + this.y * this.y + this.z * this.z; | |
| }, | |
| length: function () { | |
| return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z ); | |
| }, | |
| lengthManhattan: function () { | |
| return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ); | |
| }, | |
| normalize: function () { | |
| return this.divideScalar( this.length() ); | |
| }, | |
| setLength: function ( length ) { | |
| return this.multiplyScalar( length / this.length() ); | |
| }, | |
| lerp: function ( v, alpha ) { | |
| this.x += ( v.x - this.x ) * alpha; | |
| this.y += ( v.y - this.y ) * alpha; | |
| this.z += ( v.z - this.z ) * alpha; | |
| return this; | |
| }, | |
| lerpVectors: function ( v1, v2, alpha ) { | |
| this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 ); | |
| return this; | |
| }, | |
| cross: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' ); | |
| return this.crossVectors( v, w ); | |
| } | |
| var x = this.x, y = this.y, z = this.z; | |
| this.x = y * v.z - z * v.y; | |
| this.y = z * v.x - x * v.z; | |
| this.z = x * v.y - y * v.x; | |
| return this; | |
| }, | |
| crossVectors: function ( a, b ) { | |
| var ax = a.x, ay = a.y, az = a.z; | |
| var bx = b.x, by = b.y, bz = b.z; | |
| this.x = ay * bz - az * by; | |
| this.y = az * bx - ax * bz; | |
| this.z = ax * by - ay * bx; | |
| return this; | |
| }, | |
| projectOnVector: function () { | |
| var v1, dot; | |
| return function projectOnVector( vector ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| v1.copy( vector ).normalize(); | |
| dot = this.dot( v1 ); | |
| return this.copy( v1 ).multiplyScalar( dot ); | |
| }; | |
| }(), | |
| projectOnPlane: function () { | |
| var v1; | |
| return function projectOnPlane( planeNormal ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| v1.copy( this ).projectOnVector( planeNormal ); | |
| return this.sub( v1 ); | |
| } | |
| }(), | |
| reflect: function () { | |
| // reflect incident vector off plane orthogonal to normal | |
| // normal is assumed to have unit length | |
| var v1; | |
| return function reflect( normal ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| return this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) ); | |
| } | |
| }(), | |
| angleTo: function ( v ) { | |
| var theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) ); | |
| // clamp, to handle numerical problems | |
| return Math.acos( THREE.Math.clamp( theta, - 1, 1 ) ); | |
| }, | |
| distanceTo: function ( v ) { | |
| return Math.sqrt( this.distanceToSquared( v ) ); | |
| }, | |
| distanceToSquared: function ( v ) { | |
| var dx = this.x - v.x; | |
| var dy = this.y - v.y; | |
| var dz = this.z - v.z; | |
| return dx * dx + dy * dy + dz * dz; | |
| }, | |
| setFromMatrixPosition: function ( m ) { | |
| this.x = m.elements[ 12 ]; | |
| this.y = m.elements[ 13 ]; | |
| this.z = m.elements[ 14 ]; | |
| return this; | |
| }, | |
| setFromMatrixScale: function ( m ) { | |
| var sx = this.set( m.elements[ 0 ], m.elements[ 1 ], m.elements[ 2 ] ).length(); | |
| var sy = this.set( m.elements[ 4 ], m.elements[ 5 ], m.elements[ 6 ] ).length(); | |
| var sz = this.set( m.elements[ 8 ], m.elements[ 9 ], m.elements[ 10 ] ).length(); | |
| this.x = sx; | |
| this.y = sy; | |
| this.z = sz; | |
| return this; | |
| }, | |
| setFromMatrixColumn: function ( index, matrix ) { | |
| var offset = index * 4; | |
| var me = matrix.elements; | |
| this.x = me[ offset ]; | |
| this.y = me[ offset + 1 ]; | |
| this.z = me[ offset + 2 ]; | |
| return this; | |
| }, | |
| equals: function ( v ) { | |
| return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) ); | |
| }, | |
| fromArray: function ( array, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| this.x = array[ offset ]; | |
| this.y = array[ offset + 1 ]; | |
| this.z = array[ offset + 2 ]; | |
| return this; | |
| }, | |
| toArray: function ( array, offset ) { | |
| if ( array === undefined ) array = []; | |
| if ( offset === undefined ) offset = 0; | |
| array[ offset ] = this.x; | |
| array[ offset + 1 ] = this.y; | |
| array[ offset + 2 ] = this.z; | |
| return array; | |
| }, | |
| fromAttribute: function ( attribute, index, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| index = index * attribute.itemSize + offset; | |
| this.x = attribute.array[ index ]; | |
| this.y = attribute.array[ index + 1 ]; | |
| this.z = attribute.array[ index + 2 ]; | |
| return this; | |
| } | |
| }; | |
| // File:src/math/Vector4.js | |
| /** | |
| * @author supereggbert / http://www.paulbrunt.co.uk/ | |
| * @author philogb / http://blog.thejit.org/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author egraether / http://egraether.com/ | |
| * @author WestLangley / http://github.com/WestLangley | |
| */ | |
| THREE.Vector4 = function ( x, y, z, w ) { | |
| this.x = x || 0; | |
| this.y = y || 0; | |
| this.z = z || 0; | |
| this.w = ( w !== undefined ) ? w : 1; | |
| }; | |
| THREE.Vector4.prototype = { | |
| constructor: THREE.Vector4, | |
| set: function ( x, y, z, w ) { | |
| this.x = x; | |
| this.y = y; | |
| this.z = z; | |
| this.w = w; | |
| return this; | |
| }, | |
| setScalar: function ( scalar ) { | |
| this.x = scalar; | |
| this.y = scalar; | |
| this.z = scalar; | |
| this.w = scalar; | |
| return this; | |
| }, | |
| setX: function ( x ) { | |
| this.x = x; | |
| return this; | |
| }, | |
| setY: function ( y ) { | |
| this.y = y; | |
| return this; | |
| }, | |
| setZ: function ( z ) { | |
| this.z = z; | |
| return this; | |
| }, | |
| setW: function ( w ) { | |
| this.w = w; | |
| return this; | |
| }, | |
| setComponent: function ( index, value ) { | |
| switch ( index ) { | |
| case 0: this.x = value; break; | |
| case 1: this.y = value; break; | |
| case 2: this.z = value; break; | |
| case 3: this.w = value; break; | |
| default: throw new Error( 'index is out of range: ' + index ); | |
| } | |
| }, | |
| getComponent: function ( index ) { | |
| switch ( index ) { | |
| case 0: return this.x; | |
| case 1: return this.y; | |
| case 2: return this.z; | |
| case 3: return this.w; | |
| default: throw new Error( 'index is out of range: ' + index ); | |
| } | |
| }, | |
| clone: function () { | |
| return new this.constructor( this.x, this.y, this.z, this.w ); | |
| }, | |
| copy: function ( v ) { | |
| this.x = v.x; | |
| this.y = v.y; | |
| this.z = v.z; | |
| this.w = ( v.w !== undefined ) ? v.w : 1; | |
| return this; | |
| }, | |
| add: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' ); | |
| return this.addVectors( v, w ); | |
| } | |
| this.x += v.x; | |
| this.y += v.y; | |
| this.z += v.z; | |
| this.w += v.w; | |
| return this; | |
| }, | |
| addScalar: function ( s ) { | |
| this.x += s; | |
| this.y += s; | |
| this.z += s; | |
| this.w += s; | |
| return this; | |
| }, | |
| addVectors: function ( a, b ) { | |
| this.x = a.x + b.x; | |
| this.y = a.y + b.y; | |
| this.z = a.z + b.z; | |
| this.w = a.w + b.w; | |
| return this; | |
| }, | |
| addScaledVector: function ( v, s ) { | |
| this.x += v.x * s; | |
| this.y += v.y * s; | |
| this.z += v.z * s; | |
| this.w += v.w * s; | |
| return this; | |
| }, | |
| sub: function ( v, w ) { | |
| if ( w !== undefined ) { | |
| console.warn( 'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' ); | |
| return this.subVectors( v, w ); | |
| } | |
| this.x -= v.x; | |
| this.y -= v.y; | |
| this.z -= v.z; | |
| this.w -= v.w; | |
| return this; | |
| }, | |
| subScalar: function ( s ) { | |
| this.x -= s; | |
| this.y -= s; | |
| this.z -= s; | |
| this.w -= s; | |
| return this; | |
| }, | |
| subVectors: function ( a, b ) { | |
| this.x = a.x - b.x; | |
| this.y = a.y - b.y; | |
| this.z = a.z - b.z; | |
| this.w = a.w - b.w; | |
| return this; | |
| }, | |
| multiplyScalar: function ( scalar ) { | |
| if ( isFinite( scalar ) ) { | |
| this.x *= scalar; | |
| this.y *= scalar; | |
| this.z *= scalar; | |
| this.w *= scalar; | |
| } else { | |
| this.x = 0; | |
| this.y = 0; | |
| this.z = 0; | |
| this.w = 0; | |
| } | |
| return this; | |
| }, | |
| applyMatrix4: function ( m ) { | |
| var x = this.x; | |
| var y = this.y; | |
| var z = this.z; | |
| var w = this.w; | |
| var e = m.elements; | |
| this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w; | |
| this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w; | |
| this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w; | |
| this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w; | |
| return this; | |
| }, | |
| divideScalar: function ( scalar ) { | |
| return this.multiplyScalar( 1 / scalar ); | |
| }, | |
| setAxisAngleFromQuaternion: function ( q ) { | |
| // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm | |
| // q is assumed to be normalized | |
| this.w = 2 * Math.acos( q.w ); | |
| var s = Math.sqrt( 1 - q.w * q.w ); | |
| if ( s < 0.0001 ) { | |
| this.x = 1; | |
| this.y = 0; | |
| this.z = 0; | |
| } else { | |
| this.x = q.x / s; | |
| this.y = q.y / s; | |
| this.z = q.z / s; | |
| } | |
| return this; | |
| }, | |
| setAxisAngleFromRotationMatrix: function ( m ) { | |
| // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm | |
| // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) | |
| var angle, x, y, z, // variables for result | |
| epsilon = 0.01, // margin to allow for rounding errors | |
| epsilon2 = 0.1, // margin to distinguish between 0 and 180 degrees | |
| te = m.elements, | |
| m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ], | |
| m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ], | |
| m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ]; | |
| if ( ( Math.abs( m12 - m21 ) < epsilon ) | |
| && ( Math.abs( m13 - m31 ) < epsilon ) | |
| && ( Math.abs( m23 - m32 ) < epsilon ) ) { | |
| // singularity found | |
| // first check for identity matrix which must have +1 for all terms | |
| // in leading diagonal and zero in other terms | |
| if ( ( Math.abs( m12 + m21 ) < epsilon2 ) | |
| && ( Math.abs( m13 + m31 ) < epsilon2 ) | |
| && ( Math.abs( m23 + m32 ) < epsilon2 ) | |
| && ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) { | |
| // this singularity is identity matrix so angle = 0 | |
| this.set( 1, 0, 0, 0 ); | |
| return this; // zero angle, arbitrary axis | |
| } | |
| // otherwise this singularity is angle = 180 | |
| angle = Math.PI; | |
| var xx = ( m11 + 1 ) / 2; | |
| var yy = ( m22 + 1 ) / 2; | |
| var zz = ( m33 + 1 ) / 2; | |
| var xy = ( m12 + m21 ) / 4; | |
| var xz = ( m13 + m31 ) / 4; | |
| var yz = ( m23 + m32 ) / 4; | |
| if ( ( xx > yy ) && ( xx > zz ) ) { | |
| // m11 is the largest diagonal term | |
| if ( xx < epsilon ) { | |
| x = 0; | |
| y = 0.707106781; | |
| z = 0.707106781; | |
| } else { | |
| x = Math.sqrt( xx ); | |
| y = xy / x; | |
| z = xz / x; | |
| } | |
| } else if ( yy > zz ) { | |
| // m22 is the largest diagonal term | |
| if ( yy < epsilon ) { | |
| x = 0.707106781; | |
| y = 0; | |
| z = 0.707106781; | |
| } else { | |
| y = Math.sqrt( yy ); | |
| x = xy / y; | |
| z = yz / y; | |
| } | |
| } else { | |
| // m33 is the largest diagonal term so base result on this | |
| if ( zz < epsilon ) { | |
| x = 0.707106781; | |
| y = 0.707106781; | |
| z = 0; | |
| } else { | |
| z = Math.sqrt( zz ); | |
| x = xz / z; | |
| y = yz / z; | |
| } | |
| } | |
| this.set( x, y, z, angle ); | |
| return this; // return 180 deg rotation | |
| } | |
| // as we have reached here there are no singularities so we can handle normally | |
| var s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) | |
| + ( m13 - m31 ) * ( m13 - m31 ) | |
| + ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize | |
| if ( Math.abs( s ) < 0.001 ) s = 1; | |
| // prevent divide by zero, should not happen if matrix is orthogonal and should be | |
| // caught by singularity test above, but I've left it in just in case | |
| this.x = ( m32 - m23 ) / s; | |
| this.y = ( m13 - m31 ) / s; | |
| this.z = ( m21 - m12 ) / s; | |
| this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 ); | |
| return this; | |
| }, | |
| min: function ( v ) { | |
| this.x = Math.min( this.x, v.x ); | |
| this.y = Math.min( this.y, v.y ); | |
| this.z = Math.min( this.z, v.z ); | |
| this.w = Math.min( this.w, v.w ); | |
| return this; | |
| }, | |
| max: function ( v ) { | |
| this.x = Math.max( this.x, v.x ); | |
| this.y = Math.max( this.y, v.y ); | |
| this.z = Math.max( this.z, v.z ); | |
| this.w = Math.max( this.w, v.w ); | |
| return this; | |
| }, | |
| clamp: function ( min, max ) { | |
| // This function assumes min < max, if this assumption isn't true it will not operate correctly | |
| this.x = Math.max( min.x, Math.min( max.x, this.x ) ); | |
| this.y = Math.max( min.y, Math.min( max.y, this.y ) ); | |
| this.z = Math.max( min.z, Math.min( max.z, this.z ) ); | |
| this.w = Math.max( min.w, Math.min( max.w, this.w ) ); | |
| return this; | |
| }, | |
| clampScalar: function () { | |
| var min, max; | |
| return function clampScalar( minVal, maxVal ) { | |
| if ( min === undefined ) { | |
| min = new THREE.Vector4(); | |
| max = new THREE.Vector4(); | |
| } | |
| min.set( minVal, minVal, minVal, minVal ); | |
| max.set( maxVal, maxVal, maxVal, maxVal ); | |
| return this.clamp( min, max ); | |
| }; | |
| }(), | |
| floor: function () { | |
| this.x = Math.floor( this.x ); | |
| this.y = Math.floor( this.y ); | |
| this.z = Math.floor( this.z ); | |
| this.w = Math.floor( this.w ); | |
| return this; | |
| }, | |
| ceil: function () { | |
| this.x = Math.ceil( this.x ); | |
| this.y = Math.ceil( this.y ); | |
| this.z = Math.ceil( this.z ); | |
| this.w = Math.ceil( this.w ); | |
| return this; | |
| }, | |
| round: function () { | |
| this.x = Math.round( this.x ); | |
| this.y = Math.round( this.y ); | |
| this.z = Math.round( this.z ); | |
| this.w = Math.round( this.w ); | |
| return this; | |
| }, | |
| roundToZero: function () { | |
| this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x ); | |
| this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y ); | |
| this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z ); | |
| this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w ); | |
| return this; | |
| }, | |
| negate: function () { | |
| this.x = - this.x; | |
| this.y = - this.y; | |
| this.z = - this.z; | |
| this.w = - this.w; | |
| return this; | |
| }, | |
| dot: function ( v ) { | |
| return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w; | |
| }, | |
| lengthSq: function () { | |
| return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w; | |
| }, | |
| length: function () { | |
| return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w ); | |
| }, | |
| lengthManhattan: function () { | |
| return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w ); | |
| }, | |
| normalize: function () { | |
| return this.divideScalar( this.length() ); | |
| }, | |
| setLength: function ( length ) { | |
| return this.multiplyScalar( length / this.length() ); | |
| }, | |
| lerp: function ( v, alpha ) { | |
| this.x += ( v.x - this.x ) * alpha; | |
| this.y += ( v.y - this.y ) * alpha; | |
| this.z += ( v.z - this.z ) * alpha; | |
| this.w += ( v.w - this.w ) * alpha; | |
| return this; | |
| }, | |
| lerpVectors: function ( v1, v2, alpha ) { | |
| this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 ); | |
| return this; | |
| }, | |
| equals: function ( v ) { | |
| return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) ); | |
| }, | |
| fromArray: function ( array, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| this.x = array[ offset ]; | |
| this.y = array[ offset + 1 ]; | |
| this.z = array[ offset + 2 ]; | |
| this.w = array[ offset + 3 ]; | |
| return this; | |
| }, | |
| toArray: function ( array, offset ) { | |
| if ( array === undefined ) array = []; | |
| if ( offset === undefined ) offset = 0; | |
| array[ offset ] = this.x; | |
| array[ offset + 1 ] = this.y; | |
| array[ offset + 2 ] = this.z; | |
| array[ offset + 3 ] = this.w; | |
| return array; | |
| }, | |
| fromAttribute: function ( attribute, index, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| index = index * attribute.itemSize + offset; | |
| this.x = attribute.array[ index ]; | |
| this.y = attribute.array[ index + 1 ]; | |
| this.z = attribute.array[ index + 2 ]; | |
| this.w = attribute.array[ index + 3 ]; | |
| return this; | |
| } | |
| }; | |
| // File:src/math/Euler.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author WestLangley / http://github.com/WestLangley | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Euler = function ( x, y, z, order ) { | |
| this._x = x || 0; | |
| this._y = y || 0; | |
| this._z = z || 0; | |
| this._order = order || THREE.Euler.DefaultOrder; | |
| }; | |
| THREE.Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ]; | |
| THREE.Euler.DefaultOrder = 'XYZ'; | |
| THREE.Euler.prototype = { | |
| constructor: THREE.Euler, | |
| get x () { | |
| return this._x; | |
| }, | |
| set x ( value ) { | |
| this._x = value; | |
| this.onChangeCallback(); | |
| }, | |
| get y () { | |
| return this._y; | |
| }, | |
| set y ( value ) { | |
| this._y = value; | |
| this.onChangeCallback(); | |
| }, | |
| get z () { | |
| return this._z; | |
| }, | |
| set z ( value ) { | |
| this._z = value; | |
| this.onChangeCallback(); | |
| }, | |
| get order () { | |
| return this._order; | |
| }, | |
| set order ( value ) { | |
| this._order = value; | |
| this.onChangeCallback(); | |
| }, | |
| set: function ( x, y, z, order ) { | |
| this._x = x; | |
| this._y = y; | |
| this._z = z; | |
| this._order = order || this._order; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor( this._x, this._y, this._z, this._order ); | |
| }, | |
| copy: function ( euler ) { | |
| this._x = euler._x; | |
| this._y = euler._y; | |
| this._z = euler._z; | |
| this._order = euler._order; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| setFromRotationMatrix: function ( m, order, update ) { | |
| var clamp = THREE.Math.clamp; | |
| // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) | |
| var te = m.elements; | |
| var m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ]; | |
| var m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ]; | |
| var m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ]; | |
| order = order || this._order; | |
| if ( order === 'XYZ' ) { | |
| this._y = Math.asin( clamp( m13, - 1, 1 ) ); | |
| if ( Math.abs( m13 ) < 0.99999 ) { | |
| this._x = Math.atan2( - m23, m33 ); | |
| this._z = Math.atan2( - m12, m11 ); | |
| } else { | |
| this._x = Math.atan2( m32, m22 ); | |
| this._z = 0; | |
| } | |
| } else if ( order === 'YXZ' ) { | |
| this._x = Math.asin( - clamp( m23, - 1, 1 ) ); | |
| if ( Math.abs( m23 ) < 0.99999 ) { | |
| this._y = Math.atan2( m13, m33 ); | |
| this._z = Math.atan2( m21, m22 ); | |
| } else { | |
| this._y = Math.atan2( - m31, m11 ); | |
| this._z = 0; | |
| } | |
| } else if ( order === 'ZXY' ) { | |
| this._x = Math.asin( clamp( m32, - 1, 1 ) ); | |
| if ( Math.abs( m32 ) < 0.99999 ) { | |
| this._y = Math.atan2( - m31, m33 ); | |
| this._z = Math.atan2( - m12, m22 ); | |
| } else { | |
| this._y = 0; | |
| this._z = Math.atan2( m21, m11 ); | |
| } | |
| } else if ( order === 'ZYX' ) { | |
| this._y = Math.asin( - clamp( m31, - 1, 1 ) ); | |
| if ( Math.abs( m31 ) < 0.99999 ) { | |
| this._x = Math.atan2( m32, m33 ); | |
| this._z = Math.atan2( m21, m11 ); | |
| } else { | |
| this._x = 0; | |
| this._z = Math.atan2( - m12, m22 ); | |
| } | |
| } else if ( order === 'YZX' ) { | |
| this._z = Math.asin( clamp( m21, - 1, 1 ) ); | |
| if ( Math.abs( m21 ) < 0.99999 ) { | |
| this._x = Math.atan2( - m23, m22 ); | |
| this._y = Math.atan2( - m31, m11 ); | |
| } else { | |
| this._x = 0; | |
| this._y = Math.atan2( m13, m33 ); | |
| } | |
| } else if ( order === 'XZY' ) { | |
| this._z = Math.asin( - clamp( m12, - 1, 1 ) ); | |
| if ( Math.abs( m12 ) < 0.99999 ) { | |
| this._x = Math.atan2( m32, m22 ); | |
| this._y = Math.atan2( m13, m11 ); | |
| } else { | |
| this._x = Math.atan2( - m23, m33 ); | |
| this._y = 0; | |
| } | |
| } else { | |
| console.warn( 'THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order ) | |
| } | |
| this._order = order; | |
| if ( update !== false ) this.onChangeCallback(); | |
| return this; | |
| }, | |
| setFromQuaternion: function () { | |
| var matrix; | |
| return function ( q, order, update ) { | |
| if ( matrix === undefined ) matrix = new THREE.Matrix4(); | |
| matrix.makeRotationFromQuaternion( q ); | |
| this.setFromRotationMatrix( matrix, order, update ); | |
| return this; | |
| }; | |
| }(), | |
| setFromVector3: function ( v, order ) { | |
| return this.set( v.x, v.y, v.z, order || this._order ); | |
| }, | |
| reorder: function () { | |
| // WARNING: this discards revolution information -bhouston | |
| var q = new THREE.Quaternion(); | |
| return function ( newOrder ) { | |
| q.setFromEuler( this ); | |
| this.setFromQuaternion( q, newOrder ); | |
| }; | |
| }(), | |
| equals: function ( euler ) { | |
| return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order ); | |
| }, | |
| fromArray: function ( array ) { | |
| this._x = array[ 0 ]; | |
| this._y = array[ 1 ]; | |
| this._z = array[ 2 ]; | |
| if ( array[ 3 ] !== undefined ) this._order = array[ 3 ]; | |
| this.onChangeCallback(); | |
| return this; | |
| }, | |
| toArray: function ( array, offset ) { | |
| if ( array === undefined ) array = []; | |
| if ( offset === undefined ) offset = 0; | |
| array[ offset ] = this._x; | |
| array[ offset + 1 ] = this._y; | |
| array[ offset + 2 ] = this._z; | |
| array[ offset + 3 ] = this._order; | |
| return array; | |
| }, | |
| toVector3: function ( optionalResult ) { | |
| if ( optionalResult ) { | |
| return optionalResult.set( this._x, this._y, this._z ); | |
| } else { | |
| return new THREE.Vector3( this._x, this._y, this._z ); | |
| } | |
| }, | |
| onChange: function ( callback ) { | |
| this.onChangeCallback = callback; | |
| return this; | |
| }, | |
| onChangeCallback: function () {} | |
| }; | |
| // File:src/math/Line3.js | |
| /** | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Line3 = function ( start, end ) { | |
| this.start = ( start !== undefined ) ? start : new THREE.Vector3(); | |
| this.end = ( end !== undefined ) ? end : new THREE.Vector3(); | |
| }; | |
| THREE.Line3.prototype = { | |
| constructor: THREE.Line3, | |
| set: function ( start, end ) { | |
| this.start.copy( start ); | |
| this.end.copy( end ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( line ) { | |
| this.start.copy( line.start ); | |
| this.end.copy( line.end ); | |
| return this; | |
| }, | |
| center: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.addVectors( this.start, this.end ).multiplyScalar( 0.5 ); | |
| }, | |
| delta: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.subVectors( this.end, this.start ); | |
| }, | |
| distanceSq: function () { | |
| return this.start.distanceToSquared( this.end ); | |
| }, | |
| distance: function () { | |
| return this.start.distanceTo( this.end ); | |
| }, | |
| at: function ( t, optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return this.delta( result ).multiplyScalar( t ).add( this.start ); | |
| }, | |
| closestPointToPointParameter: function () { | |
| var startP = new THREE.Vector3(); | |
| var startEnd = new THREE.Vector3(); | |
| return function ( point, clampToLine ) { | |
| startP.subVectors( point, this.start ); | |
| startEnd.subVectors( this.end, this.start ); | |
| var startEnd2 = startEnd.dot( startEnd ); | |
| var startEnd_startP = startEnd.dot( startP ); | |
| var t = startEnd_startP / startEnd2; | |
| if ( clampToLine ) { | |
| t = THREE.Math.clamp( t, 0, 1 ); | |
| } | |
| return t; | |
| }; | |
| }(), | |
| closestPointToPoint: function ( point, clampToLine, optionalTarget ) { | |
| var t = this.closestPointToPointParameter( point, clampToLine ); | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return this.delta( result ).multiplyScalar( t ).add( this.start ); | |
| }, | |
| applyMatrix4: function ( matrix ) { | |
| this.start.applyMatrix4( matrix ); | |
| this.end.applyMatrix4( matrix ); | |
| return this; | |
| }, | |
| equals: function ( line ) { | |
| return line.start.equals( this.start ) && line.end.equals( this.end ); | |
| } | |
| }; | |
| // File:src/math/Box2.js | |
| /** | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Box2 = function ( min, max ) { | |
| this.min = ( min !== undefined ) ? min : new THREE.Vector2( + Infinity, + Infinity ); | |
| this.max = ( max !== undefined ) ? max : new THREE.Vector2( - Infinity, - Infinity ); | |
| }; | |
| THREE.Box2.prototype = { | |
| constructor: THREE.Box2, | |
| set: function ( min, max ) { | |
| this.min.copy( min ); | |
| this.max.copy( max ); | |
| return this; | |
| }, | |
| setFromPoints: function ( points ) { | |
| this.makeEmpty(); | |
| for ( var i = 0, il = points.length; i < il; i ++ ) { | |
| this.expandByPoint( points[ i ] ); | |
| } | |
| return this; | |
| }, | |
| setFromCenterAndSize: function () { | |
| var v1 = new THREE.Vector2(); | |
| return function ( center, size ) { | |
| var halfSize = v1.copy( size ).multiplyScalar( 0.5 ); | |
| this.min.copy( center ).sub( halfSize ); | |
| this.max.copy( center ).add( halfSize ); | |
| return this; | |
| }; | |
| }(), | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( box ) { | |
| this.min.copy( box.min ); | |
| this.max.copy( box.max ); | |
| return this; | |
| }, | |
| makeEmpty: function () { | |
| this.min.x = this.min.y = + Infinity; | |
| this.max.x = this.max.y = - Infinity; | |
| return this; | |
| }, | |
| isEmpty: function () { | |
| // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes | |
| return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ); | |
| }, | |
| center: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector2(); | |
| return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 ); | |
| }, | |
| size: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector2(); | |
| return result.subVectors( this.max, this.min ); | |
| }, | |
| expandByPoint: function ( point ) { | |
| this.min.min( point ); | |
| this.max.max( point ); | |
| return this; | |
| }, | |
| expandByVector: function ( vector ) { | |
| this.min.sub( vector ); | |
| this.max.add( vector ); | |
| return this; | |
| }, | |
| expandByScalar: function ( scalar ) { | |
| this.min.addScalar( - scalar ); | |
| this.max.addScalar( scalar ); | |
| return this; | |
| }, | |
| containsPoint: function ( point ) { | |
| if ( point.x < this.min.x || point.x > this.max.x || | |
| point.y < this.min.y || point.y > this.max.y ) { | |
| return false; | |
| } | |
| return true; | |
| }, | |
| containsBox: function ( box ) { | |
| if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) && | |
| ( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) ) { | |
| return true; | |
| } | |
| return false; | |
| }, | |
| getParameter: function ( point, optionalTarget ) { | |
| // This can potentially have a divide by zero if the box | |
| // has a size dimension of 0. | |
| var result = optionalTarget || new THREE.Vector2(); | |
| return result.set( | |
| ( point.x - this.min.x ) / ( this.max.x - this.min.x ), | |
| ( point.y - this.min.y ) / ( this.max.y - this.min.y ) | |
| ); | |
| }, | |
| intersectsBox: function ( box ) { | |
| // using 6 splitting planes to rule out intersections. | |
| if ( box.max.x < this.min.x || box.min.x > this.max.x || | |
| box.max.y < this.min.y || box.min.y > this.max.y ) { | |
| return false; | |
| } | |
| return true; | |
| }, | |
| clampPoint: function ( point, optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector2(); | |
| return result.copy( point ).clamp( this.min, this.max ); | |
| }, | |
| distanceToPoint: function () { | |
| var v1 = new THREE.Vector2(); | |
| return function ( point ) { | |
| var clampedPoint = v1.copy( point ).clamp( this.min, this.max ); | |
| return clampedPoint.sub( point ).length(); | |
| }; | |
| }(), | |
| intersect: function ( box ) { | |
| this.min.max( box.min ); | |
| this.max.min( box.max ); | |
| return this; | |
| }, | |
| union: function ( box ) { | |
| this.min.min( box.min ); | |
| this.max.max( box.max ); | |
| return this; | |
| }, | |
| translate: function ( offset ) { | |
| this.min.add( offset ); | |
| this.max.add( offset ); | |
| return this; | |
| }, | |
| equals: function ( box ) { | |
| return box.min.equals( this.min ) && box.max.equals( this.max ); | |
| } | |
| }; | |
| // File:src/math/Box3.js | |
| /** | |
| * @author bhouston / http://clara.io | |
| * @author WestLangley / http://github.com/WestLangley | |
| */ | |
| THREE.Box3 = function ( min, max ) { | |
| this.min = ( min !== undefined ) ? min : new THREE.Vector3( + Infinity, + Infinity, + Infinity ); | |
| this.max = ( max !== undefined ) ? max : new THREE.Vector3( - Infinity, - Infinity, - Infinity ); | |
| }; | |
| THREE.Box3.prototype = { | |
| constructor: THREE.Box3, | |
| set: function ( min, max ) { | |
| this.min.copy( min ); | |
| this.max.copy( max ); | |
| return this; | |
| }, | |
| setFromArray: function ( array ) { | |
| this.makeEmpty(); | |
| var minX = + Infinity; | |
| var minY = + Infinity; | |
| var minZ = + Infinity; | |
| var maxX = - Infinity; | |
| var maxY = - Infinity; | |
| var maxZ = - Infinity; | |
| for ( var i = 0, il = array.length; i < il; i += 3 ) { | |
| var x = array[ i ]; | |
| var y = array[ i + 1 ]; | |
| var z = array[ i + 2 ]; | |
| if ( x < minX ) minX = x; | |
| if ( y < minY ) minY = y; | |
| if ( z < minZ ) minZ = z; | |
| if ( x > maxX ) maxX = x; | |
| if ( y > maxY ) maxY = y; | |
| if ( z > maxZ ) maxZ = z; | |
| } | |
| this.min.set( minX, minY, minZ ); | |
| this.max.set( maxX, maxY, maxZ ); | |
| }, | |
| setFromPoints: function ( points ) { | |
| this.makeEmpty(); | |
| for ( var i = 0, il = points.length; i < il; i ++ ) { | |
| this.expandByPoint( points[ i ] ); | |
| } | |
| return this; | |
| }, | |
| setFromCenterAndSize: function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( center, size ) { | |
| var halfSize = v1.copy( size ).multiplyScalar( 0.5 ); | |
| this.min.copy( center ).sub( halfSize ); | |
| this.max.copy( center ).add( halfSize ); | |
| return this; | |
| }; | |
| }(), | |
| setFromObject: function () { | |
| // Computes the world-axis-aligned bounding box of an object (including its children), | |
| // accounting for both the object's, and children's, world transforms | |
| var box; | |
| return function ( object ) { | |
| if ( box === undefined ) box = new THREE.Box3(); | |
| var scope = this; | |
| this.makeEmpty(); | |
| object.updateMatrixWorld( true ); | |
| object.traverse( function ( node ) { | |
| var geometry = node.geometry; | |
| if ( geometry !== undefined ) { | |
| if ( geometry.boundingBox === null ) { | |
| geometry.computeBoundingBox(); | |
| } | |
| box.copy( geometry.boundingBox ); | |
| box.applyMatrix4( node.matrixWorld ); | |
| scope.union( box ); | |
| } | |
| } ); | |
| return this; | |
| }; | |
| }(), | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( box ) { | |
| this.min.copy( box.min ); | |
| this.max.copy( box.max ); | |
| return this; | |
| }, | |
| makeEmpty: function () { | |
| this.min.x = this.min.y = this.min.z = + Infinity; | |
| this.max.x = this.max.y = this.max.z = - Infinity; | |
| return this; | |
| }, | |
| isEmpty: function () { | |
| // this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes | |
| return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z ); | |
| }, | |
| center: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 ); | |
| }, | |
| size: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.subVectors( this.max, this.min ); | |
| }, | |
| expandByPoint: function ( point ) { | |
| this.min.min( point ); | |
| this.max.max( point ); | |
| return this; | |
| }, | |
| expandByVector: function ( vector ) { | |
| this.min.sub( vector ); | |
| this.max.add( vector ); | |
| return this; | |
| }, | |
| expandByScalar: function ( scalar ) { | |
| this.min.addScalar( - scalar ); | |
| this.max.addScalar( scalar ); | |
| return this; | |
| }, | |
| containsPoint: function ( point ) { | |
| if ( point.x < this.min.x || point.x > this.max.x || | |
| point.y < this.min.y || point.y > this.max.y || | |
| point.z < this.min.z || point.z > this.max.z ) { | |
| return false; | |
| } | |
| return true; | |
| }, | |
| containsBox: function ( box ) { | |
| if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) && | |
| ( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) && | |
| ( this.min.z <= box.min.z ) && ( box.max.z <= this.max.z ) ) { | |
| return true; | |
| } | |
| return false; | |
| }, | |
| getParameter: function ( point, optionalTarget ) { | |
| // This can potentially have a divide by zero if the box | |
| // has a size dimension of 0. | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.set( | |
| ( point.x - this.min.x ) / ( this.max.x - this.min.x ), | |
| ( point.y - this.min.y ) / ( this.max.y - this.min.y ), | |
| ( point.z - this.min.z ) / ( this.max.z - this.min.z ) | |
| ); | |
| }, | |
| intersectsBox: function ( box ) { | |
| // using 6 splitting planes to rule out intersections. | |
| if ( box.max.x < this.min.x || box.min.x > this.max.x || | |
| box.max.y < this.min.y || box.min.y > this.max.y || | |
| box.max.z < this.min.z || box.min.z > this.max.z ) { | |
| return false; | |
| } | |
| return true; | |
| }, | |
| intersectsSphere: ( function () { | |
| var closestPoint; | |
| return function intersectsSphere( sphere ) { | |
| if ( closestPoint === undefined ) closestPoint = new THREE.Vector3(); | |
| // Find the point on the AABB closest to the sphere center. | |
| this.clampPoint( sphere.center, closestPoint ); | |
| // If that point is inside the sphere, the AABB and sphere intersect. | |
| return closestPoint.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius ); | |
| }; | |
| } )(), | |
| intersectsPlane: function ( plane ) { | |
| // We compute the minimum and maximum dot product values. If those values | |
| // are on the same side (back or front) of the plane, then there is no intersection. | |
| var min, max; | |
| if ( plane.normal.x > 0 ) { | |
| min = plane.normal.x * this.min.x; | |
| max = plane.normal.x * this.max.x; | |
| } else { | |
| min = plane.normal.x * this.max.x; | |
| max = plane.normal.x * this.min.x; | |
| } | |
| if ( plane.normal.y > 0 ) { | |
| min += plane.normal.y * this.min.y; | |
| max += plane.normal.y * this.max.y; | |
| } else { | |
| min += plane.normal.y * this.max.y; | |
| max += plane.normal.y * this.min.y; | |
| } | |
| if ( plane.normal.z > 0 ) { | |
| min += plane.normal.z * this.min.z; | |
| max += plane.normal.z * this.max.z; | |
| } else { | |
| min += plane.normal.z * this.max.z; | |
| max += plane.normal.z * this.min.z; | |
| } | |
| return ( min <= plane.constant && max >= plane.constant ); | |
| }, | |
| clampPoint: function ( point, optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.copy( point ).clamp( this.min, this.max ); | |
| }, | |
| distanceToPoint: function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( point ) { | |
| var clampedPoint = v1.copy( point ).clamp( this.min, this.max ); | |
| return clampedPoint.sub( point ).length(); | |
| }; | |
| }(), | |
| getBoundingSphere: function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Sphere(); | |
| result.center = this.center(); | |
| result.radius = this.size( v1 ).length() * 0.5; | |
| return result; | |
| }; | |
| }(), | |
| intersect: function ( box ) { | |
| this.min.max( box.min ); | |
| this.max.min( box.max ); | |
| return this; | |
| }, | |
| union: function ( box ) { | |
| this.min.min( box.min ); | |
| this.max.max( box.max ); | |
| return this; | |
| }, | |
| applyMatrix4: function () { | |
| var points = [ | |
| new THREE.Vector3(), | |
| new THREE.Vector3(), | |
| new THREE.Vector3(), | |
| new THREE.Vector3(), | |
| new THREE.Vector3(), | |
| new THREE.Vector3(), | |
| new THREE.Vector3(), | |
| new THREE.Vector3() | |
| ]; | |
| return function ( matrix ) { | |
| // NOTE: I am using a binary pattern to specify all 2^3 combinations below | |
| points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000 | |
| points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001 | |
| points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010 | |
| points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011 | |
| points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100 | |
| points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101 | |
| points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110 | |
| points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111 | |
| this.makeEmpty(); | |
| this.setFromPoints( points ); | |
| return this; | |
| }; | |
| }(), | |
| translate: function ( offset ) { | |
| this.min.add( offset ); | |
| this.max.add( offset ); | |
| return this; | |
| }, | |
| equals: function ( box ) { | |
| return box.min.equals( this.min ) && box.max.equals( this.max ); | |
| } | |
| }; | |
| // File:src/math/Matrix3.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author WestLangley / http://github.com/WestLangley | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Matrix3 = function () { | |
| this.elements = new Float32Array( [ | |
| 1, 0, 0, | |
| 0, 1, 0, | |
| 0, 0, 1 | |
| ] ); | |
| if ( arguments.length > 0 ) { | |
| console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' ); | |
| } | |
| }; | |
| THREE.Matrix3.prototype = { | |
| constructor: THREE.Matrix3, | |
| set: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) { | |
| var te = this.elements; | |
| te[ 0 ] = n11; te[ 3 ] = n12; te[ 6 ] = n13; | |
| te[ 1 ] = n21; te[ 4 ] = n22; te[ 7 ] = n23; | |
| te[ 2 ] = n31; te[ 5 ] = n32; te[ 8 ] = n33; | |
| return this; | |
| }, | |
| identity: function () { | |
| this.set( | |
| 1, 0, 0, | |
| 0, 1, 0, | |
| 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().fromArray( this.elements ); | |
| }, | |
| copy: function ( m ) { | |
| var me = m.elements; | |
| this.set( | |
| me[ 0 ], me[ 3 ], me[ 6 ], | |
| me[ 1 ], me[ 4 ], me[ 7 ], | |
| me[ 2 ], me[ 5 ], me[ 8 ] | |
| ); | |
| return this; | |
| }, | |
| applyToVector3Array: function () { | |
| var v1; | |
| return function ( array, offset, length ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| if ( offset === undefined ) offset = 0; | |
| if ( length === undefined ) length = array.length; | |
| for ( var i = 0, j = offset; i < length; i += 3, j += 3 ) { | |
| v1.fromArray( array, j ); | |
| v1.applyMatrix3( this ); | |
| v1.toArray( array, j ); | |
| } | |
| return array; | |
| }; | |
| }(), | |
| applyToBuffer: function () { | |
| var v1; | |
| return function applyToBuffer( buffer, offset, length ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| if ( offset === undefined ) offset = 0; | |
| if ( length === undefined ) length = buffer.length / buffer.itemSize; | |
| for ( var i = 0, j = offset; i < length; i ++, j ++ ) { | |
| v1.x = buffer.getX( j ); | |
| v1.y = buffer.getY( j ); | |
| v1.z = buffer.getZ( j ); | |
| v1.applyMatrix3( this ); | |
| buffer.setXYZ( v1.x, v1.y, v1.z ); | |
| } | |
| return buffer; | |
| }; | |
| }(), | |
| multiplyScalar: function ( s ) { | |
| var te = this.elements; | |
| te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s; | |
| te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s; | |
| te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s; | |
| return this; | |
| }, | |
| determinant: function () { | |
| var te = this.elements; | |
| var a = te[ 0 ], b = te[ 1 ], c = te[ 2 ], | |
| d = te[ 3 ], e = te[ 4 ], f = te[ 5 ], | |
| g = te[ 6 ], h = te[ 7 ], i = te[ 8 ]; | |
| return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g; | |
| }, | |
| getInverse: function ( matrix, throwOnDegenerate ) { | |
| // input: THREE.Matrix4 | |
| // ( based on http://code.google.com/p/webgl-mjs/ ) | |
| var me = matrix.elements; | |
| var te = this.elements; | |
| te[ 0 ] = me[ 10 ] * me[ 5 ] - me[ 6 ] * me[ 9 ]; | |
| te[ 1 ] = - me[ 10 ] * me[ 1 ] + me[ 2 ] * me[ 9 ]; | |
| te[ 2 ] = me[ 6 ] * me[ 1 ] - me[ 2 ] * me[ 5 ]; | |
| te[ 3 ] = - me[ 10 ] * me[ 4 ] + me[ 6 ] * me[ 8 ]; | |
| te[ 4 ] = me[ 10 ] * me[ 0 ] - me[ 2 ] * me[ 8 ]; | |
| te[ 5 ] = - me[ 6 ] * me[ 0 ] + me[ 2 ] * me[ 4 ]; | |
| te[ 6 ] = me[ 9 ] * me[ 4 ] - me[ 5 ] * me[ 8 ]; | |
| te[ 7 ] = - me[ 9 ] * me[ 0 ] + me[ 1 ] * me[ 8 ]; | |
| te[ 8 ] = me[ 5 ] * me[ 0 ] - me[ 1 ] * me[ 4 ]; | |
| var det = me[ 0 ] * te[ 0 ] + me[ 1 ] * te[ 3 ] + me[ 2 ] * te[ 6 ]; | |
| // no inverse | |
| if ( det === 0 ) { | |
| var msg = "THREE.Matrix3.getInverse(): can't invert matrix, determinant is 0"; | |
| if ( throwOnDegenerate || false ) { | |
| throw new Error( msg ); | |
| } else { | |
| console.warn( msg ); | |
| } | |
| this.identity(); | |
| return this; | |
| } | |
| this.multiplyScalar( 1.0 / det ); | |
| return this; | |
| }, | |
| transpose: function () { | |
| var tmp, m = this.elements; | |
| tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp; | |
| tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp; | |
| tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp; | |
| return this; | |
| }, | |
| flattenToArrayOffset: function ( array, offset ) { | |
| var te = this.elements; | |
| array[ offset ] = te[ 0 ]; | |
| array[ offset + 1 ] = te[ 1 ]; | |
| array[ offset + 2 ] = te[ 2 ]; | |
| array[ offset + 3 ] = te[ 3 ]; | |
| array[ offset + 4 ] = te[ 4 ]; | |
| array[ offset + 5 ] = te[ 5 ]; | |
| array[ offset + 6 ] = te[ 6 ]; | |
| array[ offset + 7 ] = te[ 7 ]; | |
| array[ offset + 8 ] = te[ 8 ]; | |
| return array; | |
| }, | |
| getNormalMatrix: function ( m ) { | |
| // input: THREE.Matrix4 | |
| this.getInverse( m ).transpose(); | |
| return this; | |
| }, | |
| transposeIntoArray: function ( r ) { | |
| var m = this.elements; | |
| r[ 0 ] = m[ 0 ]; | |
| r[ 1 ] = m[ 3 ]; | |
| r[ 2 ] = m[ 6 ]; | |
| r[ 3 ] = m[ 1 ]; | |
| r[ 4 ] = m[ 4 ]; | |
| r[ 5 ] = m[ 7 ]; | |
| r[ 6 ] = m[ 2 ]; | |
| r[ 7 ] = m[ 5 ]; | |
| r[ 8 ] = m[ 8 ]; | |
| return this; | |
| }, | |
| fromArray: function ( array ) { | |
| this.elements.set( array ); | |
| return this; | |
| }, | |
| toArray: function () { | |
| var te = this.elements; | |
| return [ | |
| te[ 0 ], te[ 1 ], te[ 2 ], | |
| te[ 3 ], te[ 4 ], te[ 5 ], | |
| te[ 6 ], te[ 7 ], te[ 8 ] | |
| ]; | |
| } | |
| }; | |
| // File:src/math/Matrix4.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author supereggbert / http://www.paulbrunt.co.uk/ | |
| * @author philogb / http://blog.thejit.org/ | |
| * @author jordi_ros / http://plattsoft.com | |
| * @author D1plo1d / http://github.com/D1plo1d | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author timknip / http://www.floorplanner.com/ | |
| * @author bhouston / http://clara.io | |
| * @author WestLangley / http://github.com/WestLangley | |
| */ | |
| THREE.Matrix4 = function () { | |
| this.elements = new Float32Array( [ | |
| 1, 0, 0, 0, | |
| 0, 1, 0, 0, | |
| 0, 0, 1, 0, | |
| 0, 0, 0, 1 | |
| ] ); | |
| if ( arguments.length > 0 ) { | |
| console.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' ); | |
| } | |
| }; | |
| THREE.Matrix4.prototype = { | |
| constructor: THREE.Matrix4, | |
| set: function ( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) { | |
| var te = this.elements; | |
| te[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14; | |
| te[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24; | |
| te[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34; | |
| te[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44; | |
| return this; | |
| }, | |
| identity: function () { | |
| this.set( | |
| 1, 0, 0, 0, | |
| 0, 1, 0, 0, | |
| 0, 0, 1, 0, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new THREE.Matrix4().fromArray( this.elements ); | |
| }, | |
| copy: function ( m ) { | |
| this.elements.set( m.elements ); | |
| return this; | |
| }, | |
| copyPosition: function ( m ) { | |
| var te = this.elements; | |
| var me = m.elements; | |
| te[ 12 ] = me[ 12 ]; | |
| te[ 13 ] = me[ 13 ]; | |
| te[ 14 ] = me[ 14 ]; | |
| return this; | |
| }, | |
| extractBasis: function ( xAxis, yAxis, zAxis ) { | |
| var te = this.elements; | |
| xAxis.set( te[ 0 ], te[ 1 ], te[ 2 ] ); | |
| yAxis.set( te[ 4 ], te[ 5 ], te[ 6 ] ); | |
| zAxis.set( te[ 8 ], te[ 9 ], te[ 10 ] ); | |
| return this; | |
| }, | |
| makeBasis: function ( xAxis, yAxis, zAxis ) { | |
| this.set( | |
| xAxis.x, yAxis.x, zAxis.x, 0, | |
| xAxis.y, yAxis.y, zAxis.y, 0, | |
| xAxis.z, yAxis.z, zAxis.z, 0, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| extractRotation: function () { | |
| var v1; | |
| return function ( m ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| var te = this.elements; | |
| var me = m.elements; | |
| var scaleX = 1 / v1.set( me[ 0 ], me[ 1 ], me[ 2 ] ).length(); | |
| var scaleY = 1 / v1.set( me[ 4 ], me[ 5 ], me[ 6 ] ).length(); | |
| var scaleZ = 1 / v1.set( me[ 8 ], me[ 9 ], me[ 10 ] ).length(); | |
| te[ 0 ] = me[ 0 ] * scaleX; | |
| te[ 1 ] = me[ 1 ] * scaleX; | |
| te[ 2 ] = me[ 2 ] * scaleX; | |
| te[ 4 ] = me[ 4 ] * scaleY; | |
| te[ 5 ] = me[ 5 ] * scaleY; | |
| te[ 6 ] = me[ 6 ] * scaleY; | |
| te[ 8 ] = me[ 8 ] * scaleZ; | |
| te[ 9 ] = me[ 9 ] * scaleZ; | |
| te[ 10 ] = me[ 10 ] * scaleZ; | |
| return this; | |
| }; | |
| }(), | |
| makeRotationFromEuler: function ( euler ) { | |
| if ( euler instanceof THREE.Euler === false ) { | |
| console.error( 'THREE.Matrix: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.' ); | |
| } | |
| var te = this.elements; | |
| var x = euler.x, y = euler.y, z = euler.z; | |
| var a = Math.cos( x ), b = Math.sin( x ); | |
| var c = Math.cos( y ), d = Math.sin( y ); | |
| var e = Math.cos( z ), f = Math.sin( z ); | |
| if ( euler.order === 'XYZ' ) { | |
| var ae = a * e, af = a * f, be = b * e, bf = b * f; | |
| te[ 0 ] = c * e; | |
| te[ 4 ] = - c * f; | |
| te[ 8 ] = d; | |
| te[ 1 ] = af + be * d; | |
| te[ 5 ] = ae - bf * d; | |
| te[ 9 ] = - b * c; | |
| te[ 2 ] = bf - ae * d; | |
| te[ 6 ] = be + af * d; | |
| te[ 10 ] = a * c; | |
| } else if ( euler.order === 'YXZ' ) { | |
| var ce = c * e, cf = c * f, de = d * e, df = d * f; | |
| te[ 0 ] = ce + df * b; | |
| te[ 4 ] = de * b - cf; | |
| te[ 8 ] = a * d; | |
| te[ 1 ] = a * f; | |
| te[ 5 ] = a * e; | |
| te[ 9 ] = - b; | |
| te[ 2 ] = cf * b - de; | |
| te[ 6 ] = df + ce * b; | |
| te[ 10 ] = a * c; | |
| } else if ( euler.order === 'ZXY' ) { | |
| var ce = c * e, cf = c * f, de = d * e, df = d * f; | |
| te[ 0 ] = ce - df * b; | |
| te[ 4 ] = - a * f; | |
| te[ 8 ] = de + cf * b; | |
| te[ 1 ] = cf + de * b; | |
| te[ 5 ] = a * e; | |
| te[ 9 ] = df - ce * b; | |
| te[ 2 ] = - a * d; | |
| te[ 6 ] = b; | |
| te[ 10 ] = a * c; | |
| } else if ( euler.order === 'ZYX' ) { | |
| var ae = a * e, af = a * f, be = b * e, bf = b * f; | |
| te[ 0 ] = c * e; | |
| te[ 4 ] = be * d - af; | |
| te[ 8 ] = ae * d + bf; | |
| te[ 1 ] = c * f; | |
| te[ 5 ] = bf * d + ae; | |
| te[ 9 ] = af * d - be; | |
| te[ 2 ] = - d; | |
| te[ 6 ] = b * c; | |
| te[ 10 ] = a * c; | |
| } else if ( euler.order === 'YZX' ) { | |
| var ac = a * c, ad = a * d, bc = b * c, bd = b * d; | |
| te[ 0 ] = c * e; | |
| te[ 4 ] = bd - ac * f; | |
| te[ 8 ] = bc * f + ad; | |
| te[ 1 ] = f; | |
| te[ 5 ] = a * e; | |
| te[ 9 ] = - b * e; | |
| te[ 2 ] = - d * e; | |
| te[ 6 ] = ad * f + bc; | |
| te[ 10 ] = ac - bd * f; | |
| } else if ( euler.order === 'XZY' ) { | |
| var ac = a * c, ad = a * d, bc = b * c, bd = b * d; | |
| te[ 0 ] = c * e; | |
| te[ 4 ] = - f; | |
| te[ 8 ] = d * e; | |
| te[ 1 ] = ac * f + bd; | |
| te[ 5 ] = a * e; | |
| te[ 9 ] = ad * f - bc; | |
| te[ 2 ] = bc * f - ad; | |
| te[ 6 ] = b * e; | |
| te[ 10 ] = bd * f + ac; | |
| } | |
| // last column | |
| te[ 3 ] = 0; | |
| te[ 7 ] = 0; | |
| te[ 11 ] = 0; | |
| // bottom row | |
| te[ 12 ] = 0; | |
| te[ 13 ] = 0; | |
| te[ 14 ] = 0; | |
| te[ 15 ] = 1; | |
| return this; | |
| }, | |
| makeRotationFromQuaternion: function ( q ) { | |
| var te = this.elements; | |
| var x = q.x, y = q.y, z = q.z, w = q.w; | |
| var x2 = x + x, y2 = y + y, z2 = z + z; | |
| var xx = x * x2, xy = x * y2, xz = x * z2; | |
| var yy = y * y2, yz = y * z2, zz = z * z2; | |
| var wx = w * x2, wy = w * y2, wz = w * z2; | |
| te[ 0 ] = 1 - ( yy + zz ); | |
| te[ 4 ] = xy - wz; | |
| te[ 8 ] = xz + wy; | |
| te[ 1 ] = xy + wz; | |
| te[ 5 ] = 1 - ( xx + zz ); | |
| te[ 9 ] = yz - wx; | |
| te[ 2 ] = xz - wy; | |
| te[ 6 ] = yz + wx; | |
| te[ 10 ] = 1 - ( xx + yy ); | |
| // last column | |
| te[ 3 ] = 0; | |
| te[ 7 ] = 0; | |
| te[ 11 ] = 0; | |
| // bottom row | |
| te[ 12 ] = 0; | |
| te[ 13 ] = 0; | |
| te[ 14 ] = 0; | |
| te[ 15 ] = 1; | |
| return this; | |
| }, | |
| lookAt: function () { | |
| var x, y, z; | |
| return function ( eye, target, up ) { | |
| if ( x === undefined ) x = new THREE.Vector3(); | |
| if ( y === undefined ) y = new THREE.Vector3(); | |
| if ( z === undefined ) z = new THREE.Vector3(); | |
| var te = this.elements; | |
| z.subVectors( eye, target ).normalize(); | |
| if ( z.lengthSq() === 0 ) { | |
| z.z = 1; | |
| } | |
| x.crossVectors( up, z ).normalize(); | |
| if ( x.lengthSq() === 0 ) { | |
| z.x += 0.0001; | |
| x.crossVectors( up, z ).normalize(); | |
| } | |
| y.crossVectors( z, x ); | |
| te[ 0 ] = x.x; te[ 4 ] = y.x; te[ 8 ] = z.x; | |
| te[ 1 ] = x.y; te[ 5 ] = y.y; te[ 9 ] = z.y; | |
| te[ 2 ] = x.z; te[ 6 ] = y.z; te[ 10 ] = z.z; | |
| return this; | |
| }; | |
| }(), | |
| multiply: function ( m, n ) { | |
| if ( n !== undefined ) { | |
| console.warn( 'THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.' ); | |
| return this.multiplyMatrices( m, n ); | |
| } | |
| return this.multiplyMatrices( this, m ); | |
| }, | |
| multiplyMatrices: function ( a, b ) { | |
| var ae = a.elements; | |
| var be = b.elements; | |
| var te = this.elements; | |
| var a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ]; | |
| var a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ]; | |
| var a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ]; | |
| var a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ]; | |
| var b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ]; | |
| var b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ]; | |
| var b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ]; | |
| var b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ]; | |
| te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41; | |
| te[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42; | |
| te[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43; | |
| te[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44; | |
| te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41; | |
| te[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42; | |
| te[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43; | |
| te[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44; | |
| te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41; | |
| te[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42; | |
| te[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43; | |
| te[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44; | |
| te[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41; | |
| te[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42; | |
| te[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43; | |
| te[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44; | |
| return this; | |
| }, | |
| multiplyToArray: function ( a, b, r ) { | |
| var te = this.elements; | |
| this.multiplyMatrices( a, b ); | |
| r[ 0 ] = te[ 0 ]; r[ 1 ] = te[ 1 ]; r[ 2 ] = te[ 2 ]; r[ 3 ] = te[ 3 ]; | |
| r[ 4 ] = te[ 4 ]; r[ 5 ] = te[ 5 ]; r[ 6 ] = te[ 6 ]; r[ 7 ] = te[ 7 ]; | |
| r[ 8 ] = te[ 8 ]; r[ 9 ] = te[ 9 ]; r[ 10 ] = te[ 10 ]; r[ 11 ] = te[ 11 ]; | |
| r[ 12 ] = te[ 12 ]; r[ 13 ] = te[ 13 ]; r[ 14 ] = te[ 14 ]; r[ 15 ] = te[ 15 ]; | |
| return this; | |
| }, | |
| multiplyScalar: function ( s ) { | |
| var te = this.elements; | |
| te[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s; | |
| te[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s; | |
| te[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s; | |
| te[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s; | |
| return this; | |
| }, | |
| applyToVector3Array: function () { | |
| var v1; | |
| return function ( array, offset, length ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| if ( offset === undefined ) offset = 0; | |
| if ( length === undefined ) length = array.length; | |
| for ( var i = 0, j = offset; i < length; i += 3, j += 3 ) { | |
| v1.fromArray( array, j ); | |
| v1.applyMatrix4( this ); | |
| v1.toArray( array, j ); | |
| } | |
| return array; | |
| }; | |
| }(), | |
| applyToBuffer: function () { | |
| var v1; | |
| return function applyToBuffer( buffer, offset, length ) { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| if ( offset === undefined ) offset = 0; | |
| if ( length === undefined ) length = buffer.length / buffer.itemSize; | |
| for ( var i = 0, j = offset; i < length; i ++, j ++ ) { | |
| v1.x = buffer.getX( j ); | |
| v1.y = buffer.getY( j ); | |
| v1.z = buffer.getZ( j ); | |
| v1.applyMatrix4( this ); | |
| buffer.setXYZ( v1.x, v1.y, v1.z ); | |
| } | |
| return buffer; | |
| }; | |
| }(), | |
| determinant: function () { | |
| var te = this.elements; | |
| var n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ]; | |
| var n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ]; | |
| var n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ]; | |
| var n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ]; | |
| //TODO: make this more efficient | |
| //( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm ) | |
| return ( | |
| n41 * ( | |
| + n14 * n23 * n32 | |
| - n13 * n24 * n32 | |
| - n14 * n22 * n33 | |
| + n12 * n24 * n33 | |
| + n13 * n22 * n34 | |
| - n12 * n23 * n34 | |
| ) + | |
| n42 * ( | |
| + n11 * n23 * n34 | |
| - n11 * n24 * n33 | |
| + n14 * n21 * n33 | |
| - n13 * n21 * n34 | |
| + n13 * n24 * n31 | |
| - n14 * n23 * n31 | |
| ) + | |
| n43 * ( | |
| + n11 * n24 * n32 | |
| - n11 * n22 * n34 | |
| - n14 * n21 * n32 | |
| + n12 * n21 * n34 | |
| + n14 * n22 * n31 | |
| - n12 * n24 * n31 | |
| ) + | |
| n44 * ( | |
| - n13 * n22 * n31 | |
| - n11 * n23 * n32 | |
| + n11 * n22 * n33 | |
| + n13 * n21 * n32 | |
| - n12 * n21 * n33 | |
| + n12 * n23 * n31 | |
| ) | |
| ); | |
| }, | |
| transpose: function () { | |
| var te = this.elements; | |
| var tmp; | |
| tmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp; | |
| tmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp; | |
| tmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp; | |
| tmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp; | |
| tmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp; | |
| tmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp; | |
| return this; | |
| }, | |
| flattenToArrayOffset: function ( array, offset ) { | |
| var te = this.elements; | |
| array[ offset ] = te[ 0 ]; | |
| array[ offset + 1 ] = te[ 1 ]; | |
| array[ offset + 2 ] = te[ 2 ]; | |
| array[ offset + 3 ] = te[ 3 ]; | |
| array[ offset + 4 ] = te[ 4 ]; | |
| array[ offset + 5 ] = te[ 5 ]; | |
| array[ offset + 6 ] = te[ 6 ]; | |
| array[ offset + 7 ] = te[ 7 ]; | |
| array[ offset + 8 ] = te[ 8 ]; | |
| array[ offset + 9 ] = te[ 9 ]; | |
| array[ offset + 10 ] = te[ 10 ]; | |
| array[ offset + 11 ] = te[ 11 ]; | |
| array[ offset + 12 ] = te[ 12 ]; | |
| array[ offset + 13 ] = te[ 13 ]; | |
| array[ offset + 14 ] = te[ 14 ]; | |
| array[ offset + 15 ] = te[ 15 ]; | |
| return array; | |
| }, | |
| getPosition: function () { | |
| var v1; | |
| return function () { | |
| if ( v1 === undefined ) v1 = new THREE.Vector3(); | |
| console.warn( 'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.' ); | |
| var te = this.elements; | |
| return v1.set( te[ 12 ], te[ 13 ], te[ 14 ] ); | |
| }; | |
| }(), | |
| setPosition: function ( v ) { | |
| var te = this.elements; | |
| te[ 12 ] = v.x; | |
| te[ 13 ] = v.y; | |
| te[ 14 ] = v.z; | |
| return this; | |
| }, | |
| getInverse: function ( m, throwOnInvertible ) { | |
| // based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm | |
| var te = this.elements; | |
| var me = m.elements; | |
| var n11 = me[ 0 ], n12 = me[ 4 ], n13 = me[ 8 ], n14 = me[ 12 ]; | |
| var n21 = me[ 1 ], n22 = me[ 5 ], n23 = me[ 9 ], n24 = me[ 13 ]; | |
| var n31 = me[ 2 ], n32 = me[ 6 ], n33 = me[ 10 ], n34 = me[ 14 ]; | |
| var n41 = me[ 3 ], n42 = me[ 7 ], n43 = me[ 11 ], n44 = me[ 15 ]; | |
| te[ 0 ] = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44; | |
| te[ 4 ] = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44; | |
| te[ 8 ] = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44; | |
| te[ 12 ] = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34; | |
| te[ 1 ] = n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44; | |
| te[ 5 ] = n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44; | |
| te[ 9 ] = n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44; | |
| te[ 13 ] = n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34; | |
| te[ 2 ] = n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44; | |
| te[ 6 ] = n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44; | |
| te[ 10 ] = n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44; | |
| te[ 14 ] = n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34; | |
| te[ 3 ] = n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43; | |
| te[ 7 ] = n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43; | |
| te[ 11 ] = n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43; | |
| te[ 15 ] = n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33; | |
| var det = n11 * te[ 0 ] + n21 * te[ 4 ] + n31 * te[ 8 ] + n41 * te[ 12 ]; | |
| if ( det === 0 ) { | |
| var msg = "THREE.Matrix4.getInverse(): can't invert matrix, determinant is 0"; | |
| if ( throwOnInvertible || false ) { | |
| throw new Error( msg ); | |
| } else { | |
| console.warn( msg ); | |
| } | |
| this.identity(); | |
| return this; | |
| } | |
| this.multiplyScalar( 1 / det ); | |
| return this; | |
| }, | |
| scale: function ( v ) { | |
| var te = this.elements; | |
| var x = v.x, y = v.y, z = v.z; | |
| te[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z; | |
| te[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z; | |
| te[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z; | |
| te[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z; | |
| return this; | |
| }, | |
| getMaxScaleOnAxis: function () { | |
| var te = this.elements; | |
| var scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ]; | |
| var scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ]; | |
| var scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ]; | |
| return Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) ); | |
| }, | |
| makeTranslation: function ( x, y, z ) { | |
| this.set( | |
| 1, 0, 0, x, | |
| 0, 1, 0, y, | |
| 0, 0, 1, z, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| makeRotationX: function ( theta ) { | |
| var c = Math.cos( theta ), s = Math.sin( theta ); | |
| this.set( | |
| 1, 0, 0, 0, | |
| 0, c, - s, 0, | |
| 0, s, c, 0, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| makeRotationY: function ( theta ) { | |
| var c = Math.cos( theta ), s = Math.sin( theta ); | |
| this.set( | |
| c, 0, s, 0, | |
| 0, 1, 0, 0, | |
| - s, 0, c, 0, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| makeRotationZ: function ( theta ) { | |
| var c = Math.cos( theta ), s = Math.sin( theta ); | |
| this.set( | |
| c, - s, 0, 0, | |
| s, c, 0, 0, | |
| 0, 0, 1, 0, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| makeRotationAxis: function ( axis, angle ) { | |
| // Based on http://www.gamedev.net/reference/articles/article1199.asp | |
| var c = Math.cos( angle ); | |
| var s = Math.sin( angle ); | |
| var t = 1 - c; | |
| var x = axis.x, y = axis.y, z = axis.z; | |
| var tx = t * x, ty = t * y; | |
| this.set( | |
| tx * x + c, tx * y - s * z, tx * z + s * y, 0, | |
| tx * y + s * z, ty * y + c, ty * z - s * x, 0, | |
| tx * z - s * y, ty * z + s * x, t * z * z + c, 0, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| makeScale: function ( x, y, z ) { | |
| this.set( | |
| x, 0, 0, 0, | |
| 0, y, 0, 0, | |
| 0, 0, z, 0, | |
| 0, 0, 0, 1 | |
| ); | |
| return this; | |
| }, | |
| compose: function ( position, quaternion, scale ) { | |
| this.makeRotationFromQuaternion( quaternion ); | |
| this.scale( scale ); | |
| this.setPosition( position ); | |
| return this; | |
| }, | |
| decompose: function () { | |
| var vector, matrix; | |
| return function ( position, quaternion, scale ) { | |
| if ( vector === undefined ) vector = new THREE.Vector3(); | |
| if ( matrix === undefined ) matrix = new THREE.Matrix4(); | |
| var te = this.elements; | |
| var sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length(); | |
| var sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length(); | |
| var sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length(); | |
| // if determine is negative, we need to invert one scale | |
| var det = this.determinant(); | |
| if ( det < 0 ) { | |
| sx = - sx; | |
| } | |
| position.x = te[ 12 ]; | |
| position.y = te[ 13 ]; | |
| position.z = te[ 14 ]; | |
| // scale the rotation part | |
| matrix.elements.set( this.elements ); // at this point matrix is incomplete so we can't use .copy() | |
| var invSX = 1 / sx; | |
| var invSY = 1 / sy; | |
| var invSZ = 1 / sz; | |
| matrix.elements[ 0 ] *= invSX; | |
| matrix.elements[ 1 ] *= invSX; | |
| matrix.elements[ 2 ] *= invSX; | |
| matrix.elements[ 4 ] *= invSY; | |
| matrix.elements[ 5 ] *= invSY; | |
| matrix.elements[ 6 ] *= invSY; | |
| matrix.elements[ 8 ] *= invSZ; | |
| matrix.elements[ 9 ] *= invSZ; | |
| matrix.elements[ 10 ] *= invSZ; | |
| quaternion.setFromRotationMatrix( matrix ); | |
| scale.x = sx; | |
| scale.y = sy; | |
| scale.z = sz; | |
| return this; | |
| }; | |
| }(), | |
| makeFrustum: function ( left, right, bottom, top, near, far ) { | |
| var te = this.elements; | |
| var x = 2 * near / ( right - left ); | |
| var y = 2 * near / ( top - bottom ); | |
| var a = ( right + left ) / ( right - left ); | |
| var b = ( top + bottom ) / ( top - bottom ); | |
| var c = - ( far + near ) / ( far - near ); | |
| var d = - 2 * far * near / ( far - near ); | |
| te[ 0 ] = x; te[ 4 ] = 0; te[ 8 ] = a; te[ 12 ] = 0; | |
| te[ 1 ] = 0; te[ 5 ] = y; te[ 9 ] = b; te[ 13 ] = 0; | |
| te[ 2 ] = 0; te[ 6 ] = 0; te[ 10 ] = c; te[ 14 ] = d; | |
| te[ 3 ] = 0; te[ 7 ] = 0; te[ 11 ] = - 1; te[ 15 ] = 0; | |
| return this; | |
| }, | |
| makePerspective: function ( fov, aspect, near, far ) { | |
| var ymax = near * Math.tan( THREE.Math.degToRad( fov * 0.5 ) ); | |
| var ymin = - ymax; | |
| var xmin = ymin * aspect; | |
| var xmax = ymax * aspect; | |
| return this.makeFrustum( xmin, xmax, ymin, ymax, near, far ); | |
| }, | |
| makeOrthographic: function ( left, right, top, bottom, near, far ) { | |
| var te = this.elements; | |
| var w = right - left; | |
| var h = top - bottom; | |
| var p = far - near; | |
| var x = ( right + left ) / w; | |
| var y = ( top + bottom ) / h; | |
| var z = ( far + near ) / p; | |
| te[ 0 ] = 2 / w; te[ 4 ] = 0; te[ 8 ] = 0; te[ 12 ] = - x; | |
| te[ 1 ] = 0; te[ 5 ] = 2 / h; te[ 9 ] = 0; te[ 13 ] = - y; | |
| te[ 2 ] = 0; te[ 6 ] = 0; te[ 10 ] = - 2 / p; te[ 14 ] = - z; | |
| te[ 3 ] = 0; te[ 7 ] = 0; te[ 11 ] = 0; te[ 15 ] = 1; | |
| return this; | |
| }, | |
| equals: function ( matrix ) { | |
| var te = this.elements; | |
| var me = matrix.elements; | |
| for ( var i = 0; i < 16; i ++ ) { | |
| if ( te[ i ] !== me[ i ] ) return false; | |
| } | |
| return true; | |
| }, | |
| fromArray: function ( array ) { | |
| this.elements.set( array ); | |
| return this; | |
| }, | |
| toArray: function () { | |
| var te = this.elements; | |
| return [ | |
| te[ 0 ], te[ 1 ], te[ 2 ], te[ 3 ], | |
| te[ 4 ], te[ 5 ], te[ 6 ], te[ 7 ], | |
| te[ 8 ], te[ 9 ], te[ 10 ], te[ 11 ], | |
| te[ 12 ], te[ 13 ], te[ 14 ], te[ 15 ] | |
| ]; | |
| } | |
| }; | |
| // File:src/math/Ray.js | |
| /** | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Ray = function ( origin, direction ) { | |
| this.origin = ( origin !== undefined ) ? origin : new THREE.Vector3(); | |
| this.direction = ( direction !== undefined ) ? direction : new THREE.Vector3(); | |
| }; | |
| THREE.Ray.prototype = { | |
| constructor: THREE.Ray, | |
| set: function ( origin, direction ) { | |
| this.origin.copy( origin ); | |
| this.direction.copy( direction ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( ray ) { | |
| this.origin.copy( ray.origin ); | |
| this.direction.copy( ray.direction ); | |
| return this; | |
| }, | |
| at: function ( t, optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.copy( this.direction ).multiplyScalar( t ).add( this.origin ); | |
| }, | |
| lookAt: function ( v ) { | |
| this.direction.copy( v ).sub( this.origin ).normalize(); | |
| }, | |
| recast: function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( t ) { | |
| this.origin.copy( this.at( t, v1 ) ); | |
| return this; | |
| }; | |
| }(), | |
| closestPointToPoint: function ( point, optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| result.subVectors( point, this.origin ); | |
| var directionDistance = result.dot( this.direction ); | |
| if ( directionDistance < 0 ) { | |
| return result.copy( this.origin ); | |
| } | |
| return result.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin ); | |
| }, | |
| distanceToPoint: function ( point ) { | |
| return Math.sqrt( this.distanceSqToPoint( point ) ); | |
| }, | |
| distanceSqToPoint: function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( point ) { | |
| var directionDistance = v1.subVectors( point, this.origin ).dot( this.direction ); | |
| // point behind the ray | |
| if ( directionDistance < 0 ) { | |
| return this.origin.distanceToSquared( point ); | |
| } | |
| v1.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin ); | |
| return v1.distanceToSquared( point ); | |
| }; | |
| }(), | |
| distanceSqToSegment: function () { | |
| var segCenter = new THREE.Vector3(); | |
| var segDir = new THREE.Vector3(); | |
| var diff = new THREE.Vector3(); | |
| return function ( v0, v1, optionalPointOnRay, optionalPointOnSegment ) { | |
| // from http://www.geometrictools.com/LibMathematics/Distance/Wm5DistRay3Segment3.cpp | |
| // It returns the min distance between the ray and the segment | |
| // defined by v0 and v1 | |
| // It can also set two optional targets : | |
| // - The closest point on the ray | |
| // - The closest point on the segment | |
| segCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 ); | |
| segDir.copy( v1 ).sub( v0 ).normalize(); | |
| diff.copy( this.origin ).sub( segCenter ); | |
| var segExtent = v0.distanceTo( v1 ) * 0.5; | |
| var a01 = - this.direction.dot( segDir ); | |
| var b0 = diff.dot( this.direction ); | |
| var b1 = - diff.dot( segDir ); | |
| var c = diff.lengthSq(); | |
| var det = Math.abs( 1 - a01 * a01 ); | |
| var s0, s1, sqrDist, extDet; | |
| if ( det > 0 ) { | |
| // The ray and segment are not parallel. | |
| s0 = a01 * b1 - b0; | |
| s1 = a01 * b0 - b1; | |
| extDet = segExtent * det; | |
| if ( s0 >= 0 ) { | |
| if ( s1 >= - extDet ) { | |
| if ( s1 <= extDet ) { | |
| // region 0 | |
| // Minimum at interior points of ray and segment. | |
| var invDet = 1 / det; | |
| s0 *= invDet; | |
| s1 *= invDet; | |
| sqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c; | |
| } else { | |
| // region 1 | |
| s1 = segExtent; | |
| s0 = Math.max( 0, - ( a01 * s1 + b0 ) ); | |
| sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; | |
| } | |
| } else { | |
| // region 5 | |
| s1 = - segExtent; | |
| s0 = Math.max( 0, - ( a01 * s1 + b0 ) ); | |
| sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; | |
| } | |
| } else { | |
| if ( s1 <= - extDet ) { | |
| // region 4 | |
| s0 = Math.max( 0, - ( - a01 * segExtent + b0 ) ); | |
| s1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent ); | |
| sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; | |
| } else if ( s1 <= extDet ) { | |
| // region 3 | |
| s0 = 0; | |
| s1 = Math.min( Math.max( - segExtent, - b1 ), segExtent ); | |
| sqrDist = s1 * ( s1 + 2 * b1 ) + c; | |
| } else { | |
| // region 2 | |
| s0 = Math.max( 0, - ( a01 * segExtent + b0 ) ); | |
| s1 = ( s0 > 0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent ); | |
| sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; | |
| } | |
| } | |
| } else { | |
| // Ray and segment are parallel. | |
| s1 = ( a01 > 0 ) ? - segExtent : segExtent; | |
| s0 = Math.max( 0, - ( a01 * s1 + b0 ) ); | |
| sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c; | |
| } | |
| if ( optionalPointOnRay ) { | |
| optionalPointOnRay.copy( this.direction ).multiplyScalar( s0 ).add( this.origin ); | |
| } | |
| if ( optionalPointOnSegment ) { | |
| optionalPointOnSegment.copy( segDir ).multiplyScalar( s1 ).add( segCenter ); | |
| } | |
| return sqrDist; | |
| }; | |
| }(), | |
| intersectSphere: function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( sphere, optionalTarget ) { | |
| v1.subVectors( sphere.center, this.origin ); | |
| var tca = v1.dot( this.direction ); | |
| var d2 = v1.dot( v1 ) - tca * tca; | |
| var radius2 = sphere.radius * sphere.radius; | |
| if ( d2 > radius2 ) return null; | |
| var thc = Math.sqrt( radius2 - d2 ); | |
| // t0 = first intersect point - entrance on front of sphere | |
| var t0 = tca - thc; | |
| // t1 = second intersect point - exit point on back of sphere | |
| var t1 = tca + thc; | |
| // test to see if both t0 and t1 are behind the ray - if so, return null | |
| if ( t0 < 0 && t1 < 0 ) return null; | |
| // test to see if t0 is behind the ray: | |
| // if it is, the ray is inside the sphere, so return the second exit point scaled by t1, | |
| // in order to always return an intersect point that is in front of the ray. | |
| if ( t0 < 0 ) return this.at( t1, optionalTarget ); | |
| // else t0 is in front of the ray, so return the first collision point scaled by t0 | |
| return this.at( t0, optionalTarget ); | |
| } | |
| }(), | |
| intersectsSphere: function ( sphere ) { | |
| return this.distanceToPoint( sphere.center ) <= sphere.radius; | |
| }, | |
| distanceToPlane: function ( plane ) { | |
| var denominator = plane.normal.dot( this.direction ); | |
| if ( denominator === 0 ) { | |
| // line is coplanar, return origin | |
| if ( plane.distanceToPoint( this.origin ) === 0 ) { | |
| return 0; | |
| } | |
| // Null is preferable to undefined since undefined means.... it is undefined | |
| return null; | |
| } | |
| var t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator; | |
| // Return if the ray never intersects the plane | |
| return t >= 0 ? t : null; | |
| }, | |
| intersectPlane: function ( plane, optionalTarget ) { | |
| var t = this.distanceToPlane( plane ); | |
| if ( t === null ) { | |
| return null; | |
| } | |
| return this.at( t, optionalTarget ); | |
| }, | |
| intersectsPlane: function ( plane ) { | |
| // check if the ray lies on the plane first | |
| var distToPoint = plane.distanceToPoint( this.origin ); | |
| if ( distToPoint === 0 ) { | |
| return true; | |
| } | |
| var denominator = plane.normal.dot( this.direction ); | |
| if ( denominator * distToPoint < 0 ) { | |
| return true; | |
| } | |
| // ray origin is behind the plane (and is pointing behind it) | |
| return false; | |
| }, | |
| intersectBox: function ( box, optionalTarget ) { | |
| var tmin, tmax, tymin, tymax, tzmin, tzmax; | |
| var invdirx = 1 / this.direction.x, | |
| invdiry = 1 / this.direction.y, | |
| invdirz = 1 / this.direction.z; | |
| var origin = this.origin; | |
| if ( invdirx >= 0 ) { | |
| tmin = ( box.min.x - origin.x ) * invdirx; | |
| tmax = ( box.max.x - origin.x ) * invdirx; | |
| } else { | |
| tmin = ( box.max.x - origin.x ) * invdirx; | |
| tmax = ( box.min.x - origin.x ) * invdirx; | |
| } | |
| if ( invdiry >= 0 ) { | |
| tymin = ( box.min.y - origin.y ) * invdiry; | |
| tymax = ( box.max.y - origin.y ) * invdiry; | |
| } else { | |
| tymin = ( box.max.y - origin.y ) * invdiry; | |
| tymax = ( box.min.y - origin.y ) * invdiry; | |
| } | |
| if ( ( tmin > tymax ) || ( tymin > tmax ) ) return null; | |
| // These lines also handle the case where tmin or tmax is NaN | |
| // (result of 0 * Infinity). x !== x returns true if x is NaN | |
| if ( tymin > tmin || tmin !== tmin ) tmin = tymin; | |
| if ( tymax < tmax || tmax !== tmax ) tmax = tymax; | |
| if ( invdirz >= 0 ) { | |
| tzmin = ( box.min.z - origin.z ) * invdirz; | |
| tzmax = ( box.max.z - origin.z ) * invdirz; | |
| } else { | |
| tzmin = ( box.max.z - origin.z ) * invdirz; | |
| tzmax = ( box.min.z - origin.z ) * invdirz; | |
| } | |
| if ( ( tmin > tzmax ) || ( tzmin > tmax ) ) return null; | |
| if ( tzmin > tmin || tmin !== tmin ) tmin = tzmin; | |
| if ( tzmax < tmax || tmax !== tmax ) tmax = tzmax; | |
| //return point closest to the ray (positive side) | |
| if ( tmax < 0 ) return null; | |
| return this.at( tmin >= 0 ? tmin : tmax, optionalTarget ); | |
| }, | |
| intersectsBox: ( function () { | |
| var v = new THREE.Vector3(); | |
| return function ( box ) { | |
| return this.intersectBox( box, v ) !== null; | |
| }; | |
| } )(), | |
| intersectTriangle: function () { | |
| // Compute the offset origin, edges, and normal. | |
| var diff = new THREE.Vector3(); | |
| var edge1 = new THREE.Vector3(); | |
| var edge2 = new THREE.Vector3(); | |
| var normal = new THREE.Vector3(); | |
| return function ( a, b, c, backfaceCulling, optionalTarget ) { | |
| // from http://www.geometrictools.com/LibMathematics/Intersection/Wm5IntrRay3Triangle3.cpp | |
| edge1.subVectors( b, a ); | |
| edge2.subVectors( c, a ); | |
| normal.crossVectors( edge1, edge2 ); | |
| // Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction, | |
| // E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by | |
| // |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2)) | |
| // |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q)) | |
| // |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N) | |
| var DdN = this.direction.dot( normal ); | |
| var sign; | |
| if ( DdN > 0 ) { | |
| if ( backfaceCulling ) return null; | |
| sign = 1; | |
| } else if ( DdN < 0 ) { | |
| sign = - 1; | |
| DdN = - DdN; | |
| } else { | |
| return null; | |
| } | |
| diff.subVectors( this.origin, a ); | |
| var DdQxE2 = sign * this.direction.dot( edge2.crossVectors( diff, edge2 ) ); | |
| // b1 < 0, no intersection | |
| if ( DdQxE2 < 0 ) { | |
| return null; | |
| } | |
| var DdE1xQ = sign * this.direction.dot( edge1.cross( diff ) ); | |
| // b2 < 0, no intersection | |
| if ( DdE1xQ < 0 ) { | |
| return null; | |
| } | |
| // b1+b2 > 1, no intersection | |
| if ( DdQxE2 + DdE1xQ > DdN ) { | |
| return null; | |
| } | |
| // Line intersects triangle, check if ray does. | |
| var QdN = - sign * diff.dot( normal ); | |
| // t < 0, no intersection | |
| if ( QdN < 0 ) { | |
| return null; | |
| } | |
| // Ray intersects triangle. | |
| return this.at( QdN / DdN, optionalTarget ); | |
| }; | |
| }(), | |
| applyMatrix4: function ( matrix4 ) { | |
| this.direction.add( this.origin ).applyMatrix4( matrix4 ); | |
| this.origin.applyMatrix4( matrix4 ); | |
| this.direction.sub( this.origin ); | |
| this.direction.normalize(); | |
| return this; | |
| }, | |
| equals: function ( ray ) { | |
| return ray.origin.equals( this.origin ) && ray.direction.equals( this.direction ); | |
| } | |
| }; | |
| // File:src/math/Sphere.js | |
| /** | |
| * @author bhouston / http://clara.io | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Sphere = function ( center, radius ) { | |
| this.center = ( center !== undefined ) ? center : new THREE.Vector3(); | |
| this.radius = ( radius !== undefined ) ? radius : 0; | |
| }; | |
| THREE.Sphere.prototype = { | |
| constructor: THREE.Sphere, | |
| set: function ( center, radius ) { | |
| this.center.copy( center ); | |
| this.radius = radius; | |
| return this; | |
| }, | |
| setFromPoints: function () { | |
| var box = new THREE.Box3(); | |
| return function ( points, optionalCenter ) { | |
| var center = this.center; | |
| if ( optionalCenter !== undefined ) { | |
| center.copy( optionalCenter ); | |
| } else { | |
| box.setFromPoints( points ).center( center ); | |
| } | |
| var maxRadiusSq = 0; | |
| for ( var i = 0, il = points.length; i < il; i ++ ) { | |
| maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) ); | |
| } | |
| this.radius = Math.sqrt( maxRadiusSq ); | |
| return this; | |
| }; | |
| }(), | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( sphere ) { | |
| this.center.copy( sphere.center ); | |
| this.radius = sphere.radius; | |
| return this; | |
| }, | |
| empty: function () { | |
| return ( this.radius <= 0 ); | |
| }, | |
| containsPoint: function ( point ) { | |
| return ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) ); | |
| }, | |
| distanceToPoint: function ( point ) { | |
| return ( point.distanceTo( this.center ) - this.radius ); | |
| }, | |
| intersectsSphere: function ( sphere ) { | |
| var radiusSum = this.radius + sphere.radius; | |
| return sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum ); | |
| }, | |
| intersectsBox: function ( box ) { | |
| return box.intersectsSphere( this ); | |
| }, | |
| intersectsPlane: function ( plane ) { | |
| // We use the following equation to compute the signed distance from | |
| // the center of the sphere to the plane. | |
| // | |
| // distance = q * n - d | |
| // | |
| // If this distance is greater than the radius of the sphere, | |
| // then there is no intersection. | |
| return Math.abs( this.center.dot( plane.normal ) - plane.constant ) <= this.radius; | |
| }, | |
| clampPoint: function ( point, optionalTarget ) { | |
| var deltaLengthSq = this.center.distanceToSquared( point ); | |
| var result = optionalTarget || new THREE.Vector3(); | |
| result.copy( point ); | |
| if ( deltaLengthSq > ( this.radius * this.radius ) ) { | |
| result.sub( this.center ).normalize(); | |
| result.multiplyScalar( this.radius ).add( this.center ); | |
| } | |
| return result; | |
| }, | |
| getBoundingBox: function ( optionalTarget ) { | |
| var box = optionalTarget || new THREE.Box3(); | |
| box.set( this.center, this.center ); | |
| box.expandByScalar( this.radius ); | |
| return box; | |
| }, | |
| applyMatrix4: function ( matrix ) { | |
| this.center.applyMatrix4( matrix ); | |
| this.radius = this.radius * matrix.getMaxScaleOnAxis(); | |
| return this; | |
| }, | |
| translate: function ( offset ) { | |
| this.center.add( offset ); | |
| return this; | |
| }, | |
| equals: function ( sphere ) { | |
| return sphere.center.equals( this.center ) && ( sphere.radius === this.radius ); | |
| } | |
| }; | |
| // File:src/math/Frustum.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Frustum = function ( p0, p1, p2, p3, p4, p5 ) { | |
| this.planes = [ | |
| ( p0 !== undefined ) ? p0 : new THREE.Plane(), | |
| ( p1 !== undefined ) ? p1 : new THREE.Plane(), | |
| ( p2 !== undefined ) ? p2 : new THREE.Plane(), | |
| ( p3 !== undefined ) ? p3 : new THREE.Plane(), | |
| ( p4 !== undefined ) ? p4 : new THREE.Plane(), | |
| ( p5 !== undefined ) ? p5 : new THREE.Plane() | |
| ]; | |
| }; | |
| THREE.Frustum.prototype = { | |
| constructor: THREE.Frustum, | |
| set: function ( p0, p1, p2, p3, p4, p5 ) { | |
| var planes = this.planes; | |
| planes[ 0 ].copy( p0 ); | |
| planes[ 1 ].copy( p1 ); | |
| planes[ 2 ].copy( p2 ); | |
| planes[ 3 ].copy( p3 ); | |
| planes[ 4 ].copy( p4 ); | |
| planes[ 5 ].copy( p5 ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( frustum ) { | |
| var planes = this.planes; | |
| for ( var i = 0; i < 6; i ++ ) { | |
| planes[ i ].copy( frustum.planes[ i ] ); | |
| } | |
| return this; | |
| }, | |
| setFromMatrix: function ( m ) { | |
| var planes = this.planes; | |
| var me = m.elements; | |
| var me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ]; | |
| var me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ]; | |
| var me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ]; | |
| var me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ]; | |
| planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize(); | |
| planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize(); | |
| planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize(); | |
| planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize(); | |
| planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize(); | |
| planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize(); | |
| return this; | |
| }, | |
| intersectsObject: function () { | |
| var sphere = new THREE.Sphere(); | |
| return function ( object ) { | |
| var geometry = object.geometry; | |
| if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere(); | |
| sphere.copy( geometry.boundingSphere ); | |
| sphere.applyMatrix4( object.matrixWorld ); | |
| return this.intersectsSphere( sphere ); | |
| }; | |
| }(), | |
| intersectsSphere: function ( sphere ) { | |
| var planes = this.planes; | |
| var center = sphere.center; | |
| var negRadius = - sphere.radius; | |
| for ( var i = 0; i < 6; i ++ ) { | |
| var distance = planes[ i ].distanceToPoint( center ); | |
| if ( distance < negRadius ) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }, | |
| intersectsBox: function () { | |
| var p1 = new THREE.Vector3(), | |
| p2 = new THREE.Vector3(); | |
| return function ( box ) { | |
| var planes = this.planes; | |
| for ( var i = 0; i < 6 ; i ++ ) { | |
| var plane = planes[ i ]; | |
| p1.x = plane.normal.x > 0 ? box.min.x : box.max.x; | |
| p2.x = plane.normal.x > 0 ? box.max.x : box.min.x; | |
| p1.y = plane.normal.y > 0 ? box.min.y : box.max.y; | |
| p2.y = plane.normal.y > 0 ? box.max.y : box.min.y; | |
| p1.z = plane.normal.z > 0 ? box.min.z : box.max.z; | |
| p2.z = plane.normal.z > 0 ? box.max.z : box.min.z; | |
| var d1 = plane.distanceToPoint( p1 ); | |
| var d2 = plane.distanceToPoint( p2 ); | |
| // if both outside plane, no intersection | |
| if ( d1 < 0 && d2 < 0 ) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| }; | |
| }(), | |
| containsPoint: function ( point ) { | |
| var planes = this.planes; | |
| for ( var i = 0; i < 6; i ++ ) { | |
| if ( planes[ i ].distanceToPoint( point ) < 0 ) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| }; | |
| // File:src/math/Plane.js | |
| /** | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Plane = function ( normal, constant ) { | |
| this.normal = ( normal !== undefined ) ? normal : new THREE.Vector3( 1, 0, 0 ); | |
| this.constant = ( constant !== undefined ) ? constant : 0; | |
| }; | |
| THREE.Plane.prototype = { | |
| constructor: THREE.Plane, | |
| set: function ( normal, constant ) { | |
| this.normal.copy( normal ); | |
| this.constant = constant; | |
| return this; | |
| }, | |
| setComponents: function ( x, y, z, w ) { | |
| this.normal.set( x, y, z ); | |
| this.constant = w; | |
| return this; | |
| }, | |
| setFromNormalAndCoplanarPoint: function ( normal, point ) { | |
| this.normal.copy( normal ); | |
| this.constant = - point.dot( this.normal ); // must be this.normal, not normal, as this.normal is normalized | |
| return this; | |
| }, | |
| setFromCoplanarPoints: function () { | |
| var v1 = new THREE.Vector3(); | |
| var v2 = new THREE.Vector3(); | |
| return function ( a, b, c ) { | |
| var normal = v1.subVectors( c, b ).cross( v2.subVectors( a, b ) ).normalize(); | |
| // Q: should an error be thrown if normal is zero (e.g. degenerate plane)? | |
| this.setFromNormalAndCoplanarPoint( normal, a ); | |
| return this; | |
| }; | |
| }(), | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( plane ) { | |
| this.normal.copy( plane.normal ); | |
| this.constant = plane.constant; | |
| return this; | |
| }, | |
| normalize: function () { | |
| // Note: will lead to a divide by zero if the plane is invalid. | |
| var inverseNormalLength = 1.0 / this.normal.length(); | |
| this.normal.multiplyScalar( inverseNormalLength ); | |
| this.constant *= inverseNormalLength; | |
| return this; | |
| }, | |
| negate: function () { | |
| this.constant *= - 1; | |
| this.normal.negate(); | |
| return this; | |
| }, | |
| distanceToPoint: function ( point ) { | |
| return this.normal.dot( point ) + this.constant; | |
| }, | |
| distanceToSphere: function ( sphere ) { | |
| return this.distanceToPoint( sphere.center ) - sphere.radius; | |
| }, | |
| projectPoint: function ( point, optionalTarget ) { | |
| return this.orthoPoint( point, optionalTarget ).sub( point ).negate(); | |
| }, | |
| orthoPoint: function ( point, optionalTarget ) { | |
| var perpendicularMagnitude = this.distanceToPoint( point ); | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.copy( this.normal ).multiplyScalar( perpendicularMagnitude ); | |
| }, | |
| intersectLine: function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( line, optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| var direction = line.delta( v1 ); | |
| var denominator = this.normal.dot( direction ); | |
| if ( denominator === 0 ) { | |
| // line is coplanar, return origin | |
| if ( this.distanceToPoint( line.start ) === 0 ) { | |
| return result.copy( line.start ); | |
| } | |
| // Unsure if this is the correct method to handle this case. | |
| return undefined; | |
| } | |
| var t = - ( line.start.dot( this.normal ) + this.constant ) / denominator; | |
| if ( t < 0 || t > 1 ) { | |
| return undefined; | |
| } | |
| return result.copy( direction ).multiplyScalar( t ).add( line.start ); | |
| }; | |
| }(), | |
| intersectsLine: function ( line ) { | |
| // Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it. | |
| var startSign = this.distanceToPoint( line.start ); | |
| var endSign = this.distanceToPoint( line.end ); | |
| return ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 ); | |
| }, | |
| intersectsBox: function ( box ) { | |
| return box.intersectsPlane( this ); | |
| }, | |
| intersectsSphere: function ( sphere ) { | |
| return sphere.intersectsPlane( this ); | |
| }, | |
| coplanarPoint: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.copy( this.normal ).multiplyScalar( - this.constant ); | |
| }, | |
| applyMatrix4: function () { | |
| var v1 = new THREE.Vector3(); | |
| var v2 = new THREE.Vector3(); | |
| var m1 = new THREE.Matrix3(); | |
| return function ( matrix, optionalNormalMatrix ) { | |
| // compute new normal based on theory here: | |
| // http://www.songho.ca/opengl/gl_normaltransform.html | |
| var normalMatrix = optionalNormalMatrix || m1.getNormalMatrix( matrix ); | |
| var newNormal = v1.copy( this.normal ).applyMatrix3( normalMatrix ); | |
| var newCoplanarPoint = this.coplanarPoint( v2 ); | |
| newCoplanarPoint.applyMatrix4( matrix ); | |
| this.setFromNormalAndCoplanarPoint( newNormal, newCoplanarPoint ); | |
| return this; | |
| }; | |
| }(), | |
| translate: function ( offset ) { | |
| this.constant = this.constant - offset.dot( this.normal ); | |
| return this; | |
| }, | |
| equals: function ( plane ) { | |
| return plane.normal.equals( this.normal ) && ( plane.constant === this.constant ); | |
| } | |
| }; | |
| // File:src/math/Math.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Math = { | |
| generateUUID: function () { | |
| // http://www.broofa.com/Tools/Math.uuid.htm | |
| var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split( '' ); | |
| var uuid = new Array( 36 ); | |
| var rnd = 0, r; | |
| return function () { | |
| for ( var i = 0; i < 36; i ++ ) { | |
| if ( i === 8 || i === 13 || i === 18 || i === 23 ) { | |
| uuid[ i ] = '-'; | |
| } else if ( i === 14 ) { | |
| uuid[ i ] = '4'; | |
| } else { | |
| if ( rnd <= 0x02 ) rnd = 0x2000000 + ( Math.random() * 0x1000000 ) | 0; | |
| r = rnd & 0xf; | |
| rnd = rnd >> 4; | |
| uuid[ i ] = chars[ ( i === 19 ) ? ( r & 0x3 ) | 0x8 : r ]; | |
| } | |
| } | |
| return uuid.join( '' ); | |
| }; | |
| }(), | |
| clamp: function ( value, min, max ) { | |
| return Math.max( min, Math.min( max, value ) ); | |
| }, | |
| // compute euclidian modulo of m % n | |
| // https://en.wikipedia.org/wiki/Modulo_operation | |
| euclideanModulo: function ( n, m ) { | |
| return ( ( n % m ) + m ) % m; | |
| }, | |
| // Linear mapping from range <a1, a2> to range <b1, b2> | |
| mapLinear: function ( x, a1, a2, b1, b2 ) { | |
| return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 ); | |
| }, | |
| // http://en.wikipedia.org/wiki/Smoothstep | |
| smoothstep: function ( x, min, max ) { | |
| if ( x <= min ) return 0; | |
| if ( x >= max ) return 1; | |
| x = ( x - min ) / ( max - min ); | |
| return x * x * ( 3 - 2 * x ); | |
| }, | |
| smootherstep: function ( x, min, max ) { | |
| if ( x <= min ) return 0; | |
| if ( x >= max ) return 1; | |
| x = ( x - min ) / ( max - min ); | |
| return x * x * x * ( x * ( x * 6 - 15 ) + 10 ); | |
| }, | |
| random16: function () { | |
| console.warn( 'THREE.Math.random16() has been deprecated. Use Math.random() instead.' ); | |
| return Math.random(); | |
| }, | |
| // Random integer from <low, high> interval | |
| randInt: function ( low, high ) { | |
| return low + Math.floor( Math.random() * ( high - low + 1 ) ); | |
| }, | |
| // Random float from <low, high> interval | |
| randFloat: function ( low, high ) { | |
| return low + Math.random() * ( high - low ); | |
| }, | |
| // Random float from <-range/2, range/2> interval | |
| randFloatSpread: function ( range ) { | |
| return range * ( 0.5 - Math.random() ); | |
| }, | |
| degToRad: function () { | |
| var degreeToRadiansFactor = Math.PI / 180; | |
| return function ( degrees ) { | |
| return degrees * degreeToRadiansFactor; | |
| }; | |
| }(), | |
| radToDeg: function () { | |
| var radianToDegreesFactor = 180 / Math.PI; | |
| return function ( radians ) { | |
| return radians * radianToDegreesFactor; | |
| }; | |
| }(), | |
| isPowerOfTwo: function ( value ) { | |
| return ( value & ( value - 1 ) ) === 0 && value !== 0; | |
| }, | |
| nearestPowerOfTwo: function ( value ) { | |
| return Math.pow( 2, Math.round( Math.log( value ) / Math.LN2 ) ); | |
| }, | |
| nextPowerOfTwo: function ( value ) { | |
| value --; | |
| value |= value >> 1; | |
| value |= value >> 2; | |
| value |= value >> 4; | |
| value |= value >> 8; | |
| value |= value >> 16; | |
| value ++; | |
| return value; | |
| } | |
| }; | |
| // File:src/math/Spline.js | |
| /** | |
| * Spline from Tween.js, slightly optimized (and trashed) | |
| * http://sole.github.com/tween.js/examples/05_spline.html | |
| * | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Spline = function ( points ) { | |
| this.points = points; | |
| var c = [], v3 = { x: 0, y: 0, z: 0 }, | |
| point, intPoint, weight, w2, w3, | |
| pa, pb, pc, pd; | |
| this.initFromArray = function ( a ) { | |
| this.points = []; | |
| for ( var i = 0; i < a.length; i ++ ) { | |
| this.points[ i ] = { x: a[ i ][ 0 ], y: a[ i ][ 1 ], z: a[ i ][ 2 ] }; | |
| } | |
| }; | |
| this.getPoint = function ( k ) { | |
| point = ( this.points.length - 1 ) * k; | |
| intPoint = Math.floor( point ); | |
| weight = point - intPoint; | |
| c[ 0 ] = intPoint === 0 ? intPoint : intPoint - 1; | |
| c[ 1 ] = intPoint; | |
| c[ 2 ] = intPoint > this.points.length - 2 ? this.points.length - 1 : intPoint + 1; | |
| c[ 3 ] = intPoint > this.points.length - 3 ? this.points.length - 1 : intPoint + 2; | |
| pa = this.points[ c[ 0 ] ]; | |
| pb = this.points[ c[ 1 ] ]; | |
| pc = this.points[ c[ 2 ] ]; | |
| pd = this.points[ c[ 3 ] ]; | |
| w2 = weight * weight; | |
| w3 = weight * w2; | |
| v3.x = interpolate( pa.x, pb.x, pc.x, pd.x, weight, w2, w3 ); | |
| v3.y = interpolate( pa.y, pb.y, pc.y, pd.y, weight, w2, w3 ); | |
| v3.z = interpolate( pa.z, pb.z, pc.z, pd.z, weight, w2, w3 ); | |
| return v3; | |
| }; | |
| this.getControlPointsArray = function () { | |
| var i, p, l = this.points.length, | |
| coords = []; | |
| for ( i = 0; i < l; i ++ ) { | |
| p = this.points[ i ]; | |
| coords[ i ] = [ p.x, p.y, p.z ]; | |
| } | |
| return coords; | |
| }; | |
| // approximate length by summing linear segments | |
| this.getLength = function ( nSubDivisions ) { | |
| var i, index, nSamples, position, | |
| point = 0, intPoint = 0, oldIntPoint = 0, | |
| oldPosition = new THREE.Vector3(), | |
| tmpVec = new THREE.Vector3(), | |
| chunkLengths = [], | |
| totalLength = 0; | |
| // first point has 0 length | |
| chunkLengths[ 0 ] = 0; | |
| if ( ! nSubDivisions ) nSubDivisions = 100; | |
| nSamples = this.points.length * nSubDivisions; | |
| oldPosition.copy( this.points[ 0 ] ); | |
| for ( i = 1; i < nSamples; i ++ ) { | |
| index = i / nSamples; | |
| position = this.getPoint( index ); | |
| tmpVec.copy( position ); | |
| totalLength += tmpVec.distanceTo( oldPosition ); | |
| oldPosition.copy( position ); | |
| point = ( this.points.length - 1 ) * index; | |
| intPoint = Math.floor( point ); | |
| if ( intPoint !== oldIntPoint ) { | |
| chunkLengths[ intPoint ] = totalLength; | |
| oldIntPoint = intPoint; | |
| } | |
| } | |
| // last point ends with total length | |
| chunkLengths[ chunkLengths.length ] = totalLength; | |
| return { chunks: chunkLengths, total: totalLength }; | |
| }; | |
| this.reparametrizeByArcLength = function ( samplingCoef ) { | |
| var i, j, | |
| index, indexCurrent, indexNext, | |
| realDistance, | |
| sampling, position, | |
| newpoints = [], | |
| tmpVec = new THREE.Vector3(), | |
| sl = this.getLength(); | |
| newpoints.push( tmpVec.copy( this.points[ 0 ] ).clone() ); | |
| for ( i = 1; i < this.points.length; i ++ ) { | |
| //tmpVec.copy( this.points[ i - 1 ] ); | |
| //linearDistance = tmpVec.distanceTo( this.points[ i ] ); | |
| realDistance = sl.chunks[ i ] - sl.chunks[ i - 1 ]; | |
| sampling = Math.ceil( samplingCoef * realDistance / sl.total ); | |
| indexCurrent = ( i - 1 ) / ( this.points.length - 1 ); | |
| indexNext = i / ( this.points.length - 1 ); | |
| for ( j = 1; j < sampling - 1; j ++ ) { | |
| index = indexCurrent + j * ( 1 / sampling ) * ( indexNext - indexCurrent ); | |
| position = this.getPoint( index ); | |
| newpoints.push( tmpVec.copy( position ).clone() ); | |
| } | |
| newpoints.push( tmpVec.copy( this.points[ i ] ).clone() ); | |
| } | |
| this.points = newpoints; | |
| }; | |
| // Catmull-Rom | |
| function interpolate( p0, p1, p2, p3, t, t2, t3 ) { | |
| var v0 = ( p2 - p0 ) * 0.5, | |
| v1 = ( p3 - p1 ) * 0.5; | |
| return ( 2 * ( p1 - p2 ) + v0 + v1 ) * t3 + ( - 3 * ( p1 - p2 ) - 2 * v0 - v1 ) * t2 + v0 * t + p1; | |
| } | |
| }; | |
| // File:src/math/Triangle.js | |
| /** | |
| * @author bhouston / http://clara.io | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Triangle = function ( a, b, c ) { | |
| this.a = ( a !== undefined ) ? a : new THREE.Vector3(); | |
| this.b = ( b !== undefined ) ? b : new THREE.Vector3(); | |
| this.c = ( c !== undefined ) ? c : new THREE.Vector3(); | |
| }; | |
| THREE.Triangle.normal = function () { | |
| var v0 = new THREE.Vector3(); | |
| return function ( a, b, c, optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| result.subVectors( c, b ); | |
| v0.subVectors( a, b ); | |
| result.cross( v0 ); | |
| var resultLengthSq = result.lengthSq(); | |
| if ( resultLengthSq > 0 ) { | |
| return result.multiplyScalar( 1 / Math.sqrt( resultLengthSq ) ); | |
| } | |
| return result.set( 0, 0, 0 ); | |
| }; | |
| }(); | |
| // static/instance method to calculate barycentric coordinates | |
| // based on: http://www.blackpawn.com/texts/pointinpoly/default.html | |
| THREE.Triangle.barycoordFromPoint = function () { | |
| var v0 = new THREE.Vector3(); | |
| var v1 = new THREE.Vector3(); | |
| var v2 = new THREE.Vector3(); | |
| return function ( point, a, b, c, optionalTarget ) { | |
| v0.subVectors( c, a ); | |
| v1.subVectors( b, a ); | |
| v2.subVectors( point, a ); | |
| var dot00 = v0.dot( v0 ); | |
| var dot01 = v0.dot( v1 ); | |
| var dot02 = v0.dot( v2 ); | |
| var dot11 = v1.dot( v1 ); | |
| var dot12 = v1.dot( v2 ); | |
| var denom = ( dot00 * dot11 - dot01 * dot01 ); | |
| var result = optionalTarget || new THREE.Vector3(); | |
| // collinear or singular triangle | |
| if ( denom === 0 ) { | |
| // arbitrary location outside of triangle? | |
| // not sure if this is the best idea, maybe should be returning undefined | |
| return result.set( - 2, - 1, - 1 ); | |
| } | |
| var invDenom = 1 / denom; | |
| var u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom; | |
| var v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom; | |
| // barycentric coordinates must always sum to 1 | |
| return result.set( 1 - u - v, v, u ); | |
| }; | |
| }(); | |
| THREE.Triangle.containsPoint = function () { | |
| var v1 = new THREE.Vector3(); | |
| return function ( point, a, b, c ) { | |
| var result = THREE.Triangle.barycoordFromPoint( point, a, b, c, v1 ); | |
| return ( result.x >= 0 ) && ( result.y >= 0 ) && ( ( result.x + result.y ) <= 1 ); | |
| }; | |
| }(); | |
| THREE.Triangle.prototype = { | |
| constructor: THREE.Triangle, | |
| set: function ( a, b, c ) { | |
| this.a.copy( a ); | |
| this.b.copy( b ); | |
| this.c.copy( c ); | |
| return this; | |
| }, | |
| setFromPointsAndIndices: function ( points, i0, i1, i2 ) { | |
| this.a.copy( points[ i0 ] ); | |
| this.b.copy( points[ i1 ] ); | |
| this.c.copy( points[ i2 ] ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( triangle ) { | |
| this.a.copy( triangle.a ); | |
| this.b.copy( triangle.b ); | |
| this.c.copy( triangle.c ); | |
| return this; | |
| }, | |
| area: function () { | |
| var v0 = new THREE.Vector3(); | |
| var v1 = new THREE.Vector3(); | |
| return function () { | |
| v0.subVectors( this.c, this.b ); | |
| v1.subVectors( this.a, this.b ); | |
| return v0.cross( v1 ).length() * 0.5; | |
| }; | |
| }(), | |
| midpoint: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| return result.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 ); | |
| }, | |
| normal: function ( optionalTarget ) { | |
| return THREE.Triangle.normal( this.a, this.b, this.c, optionalTarget ); | |
| }, | |
| plane: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Plane(); | |
| return result.setFromCoplanarPoints( this.a, this.b, this.c ); | |
| }, | |
| barycoordFromPoint: function ( point, optionalTarget ) { | |
| return THREE.Triangle.barycoordFromPoint( point, this.a, this.b, this.c, optionalTarget ); | |
| }, | |
| containsPoint: function ( point ) { | |
| return THREE.Triangle.containsPoint( point, this.a, this.b, this.c ); | |
| }, | |
| equals: function ( triangle ) { | |
| return triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c ); | |
| } | |
| }; | |
| // File:src/math/Interpolant.js | |
| /** | |
| * Abstract base class of interpolants over parametric samples. | |
| * | |
| * The parameter domain is one dimensional, typically the time or a path | |
| * along a curve defined by the data. | |
| * | |
| * The sample values can have any dimensionality and derived classes may | |
| * apply special interpretations to the data. | |
| * | |
| * This class provides the interval seek in a Template Method, deferring | |
| * the actual interpolation to derived classes. | |
| * | |
| * Time complexity is O(1) for linear access crossing at most two points | |
| * and O(log N) for random access, where N is the number of positions. | |
| * | |
| * References: | |
| * | |
| * http://www.oodesign.com/template-method-pattern.html | |
| * | |
| * @author tschw | |
| */ | |
| THREE.Interpolant = function( | |
| parameterPositions, sampleValues, sampleSize, resultBuffer ) { | |
| this.parameterPositions = parameterPositions; | |
| this._cachedIndex = 0; | |
| this.resultBuffer = resultBuffer !== undefined ? | |
| resultBuffer : new sampleValues.constructor( sampleSize ); | |
| this.sampleValues = sampleValues; | |
| this.valueSize = sampleSize; | |
| }; | |
| THREE.Interpolant.prototype = { | |
| constructor: THREE.Interpolant, | |
| evaluate: function( t ) { | |
| var pp = this.parameterPositions, | |
| i1 = this._cachedIndex, | |
| t1 = pp[ i1 ], | |
| t0 = pp[ i1 - 1 ]; | |
| validate_interval: { | |
| seek: { | |
| var right; | |
| linear_scan: { | |
| //- See http://jsperf.com/comparison-to-undefined/3 | |
| //- slower code: | |
| //- | |
| //- if ( t >= t1 || t1 === undefined ) { | |
| forward_scan: if ( ! ( t < t1 ) ) { | |
| for ( var giveUpAt = i1 + 2; ;) { | |
| if ( t1 === undefined ) { | |
| if ( t < t0 ) break forward_scan; | |
| // after end | |
| i1 = pp.length; | |
| this._cachedIndex = i1; | |
| return this.afterEnd_( i1 - 1, t, t0 ); | |
| } | |
| if ( i1 === giveUpAt ) break; // this loop | |
| t0 = t1; | |
| t1 = pp[ ++ i1 ]; | |
| if ( t < t1 ) { | |
| // we have arrived at the sought interval | |
| break seek; | |
| } | |
| } | |
| // prepare binary search on the right side of the index | |
| right = pp.length; | |
| break linear_scan; | |
| } | |
| //- slower code: | |
| //- if ( t < t0 || t0 === undefined ) { | |
| if ( ! ( t >= t0 ) ) { | |
| // looping? | |
| var t1global = pp[ 1 ]; | |
| if ( t < t1global ) { | |
| i1 = 2; // + 1, using the scan for the details | |
| t0 = t1global; | |
| } | |
| // linear reverse scan | |
| for ( var giveUpAt = i1 - 2; ;) { | |
| if ( t0 === undefined ) { | |
| // before start | |
| this._cachedIndex = 0; | |
| return this.beforeStart_( 0, t, t1 ); | |
| } | |
| if ( i1 === giveUpAt ) break; // this loop | |
| t1 = t0; | |
| t0 = pp[ -- i1 - 1 ]; | |
| if ( t >= t0 ) { | |
| // we have arrived at the sought interval | |
| break seek; | |
| } | |
| } | |
| // prepare binary search on the left side of the index | |
| right = i1; | |
| i1 = 0; | |
| break linear_scan; | |
| } | |
| // the interval is valid | |
| break validate_interval; | |
| } // linear scan | |
| // binary search | |
| while ( i1 < right ) { | |
| var mid = ( i1 + right ) >>> 1; | |
| if ( t < pp[ mid ] ) { | |
| right = mid; | |
| } else { | |
| i1 = mid + 1; | |
| } | |
| } | |
| t1 = pp[ i1 ]; | |
| t0 = pp[ i1 - 1 ]; | |
| // check boundary cases, again | |
| if ( t0 === undefined ) { | |
| this._cachedIndex = 0; | |
| return this.beforeStart_( 0, t, t1 ); | |
| } | |
| if ( t1 === undefined ) { | |
| i1 = pp.length; | |
| this._cachedIndex = i1; | |
| return this.afterEnd_( i1 - 1, t0, t ); | |
| } | |
| } // seek | |
| this._cachedIndex = i1; | |
| this.intervalChanged_( i1, t0, t1 ); | |
| } // validate_interval | |
| return this.interpolate_( i1, t0, t, t1 ); | |
| }, | |
| settings: null, // optional, subclass-specific settings structure | |
| // Note: The indirection allows central control of many interpolants. | |
| // --- Protected interface | |
| DefaultSettings_: {}, | |
| getSettings_: function() { | |
| return this.settings || this.DefaultSettings_; | |
| }, | |
| copySampleValue_: function( index ) { | |
| // copies a sample value to the result buffer | |
| var result = this.resultBuffer, | |
| values = this.sampleValues, | |
| stride = this.valueSize, | |
| offset = index * stride; | |
| for ( var i = 0; i !== stride; ++ i ) { | |
| result[ i ] = values[ offset + i ]; | |
| } | |
| return result; | |
| }, | |
| // Template methods for derived classes: | |
| interpolate_: function( i1, t0, t, t1 ) { | |
| throw new Error( "call to abstract method" ); | |
| // implementations shall return this.resultBuffer | |
| }, | |
| intervalChanged_: function( i1, t0, t1 ) { | |
| // empty | |
| } | |
| }; | |
| Object.assign( THREE.Interpolant.prototype, { | |
| beforeStart_: //( 0, t, t0 ), returns this.resultBuffer | |
| THREE.Interpolant.prototype.copySampleValue_, | |
| afterEnd_: //( N-1, tN-1, t ), returns this.resultBuffer | |
| THREE.Interpolant.prototype.copySampleValue_ | |
| } ); | |
| // File:src/math/interpolants/CubicInterpolant.js | |
| /** | |
| * Fast and simple cubic spline interpolant. | |
| * | |
| * It was derived from a Hermitian construction setting the first derivative | |
| * at each sample position to the linear slope between neighboring positions | |
| * over their parameter interval. | |
| * | |
| * @author tschw | |
| */ | |
| THREE.CubicInterpolant = function( | |
| parameterPositions, sampleValues, sampleSize, resultBuffer ) { | |
| THREE.Interpolant.call( | |
| this, parameterPositions, sampleValues, sampleSize, resultBuffer ); | |
| this._weightPrev = -0; | |
| this._offsetPrev = -0; | |
| this._weightNext = -0; | |
| this._offsetNext = -0; | |
| }; | |
| THREE.CubicInterpolant.prototype = | |
| Object.assign( Object.create( THREE.Interpolant.prototype ), { | |
| constructor: THREE.CubicInterpolant, | |
| DefaultSettings_: { | |
| endingStart: THREE.ZeroCurvatureEnding, | |
| endingEnd: THREE.ZeroCurvatureEnding | |
| }, | |
| intervalChanged_: function( i1, t0, t1 ) { | |
| var pp = this.parameterPositions, | |
| iPrev = i1 - 2, | |
| iNext = i1 + 1, | |
| tPrev = pp[ iPrev ], | |
| tNext = pp[ iNext ]; | |
| if ( tPrev === undefined ) { | |
| switch ( this.getSettings_().endingStart ) { | |
| case THREE.ZeroSlopeEnding: | |
| // f'(t0) = 0 | |
| iPrev = i1; | |
| tPrev = 2 * t0 - t1; | |
| break; | |
| case THREE.WrapAroundEnding: | |
| // use the other end of the curve | |
| iPrev = pp.length - 2; | |
| tPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ]; | |
| break; | |
| default: // ZeroCurvatureEnding | |
| // f''(t0) = 0 a.k.a. Natural Spline | |
| iPrev = i1; | |
| tPrev = t1; | |
| } | |
| } | |
| if ( tNext === undefined ) { | |
| switch ( this.getSettings_().endingEnd ) { | |
| case THREE.ZeroSlopeEnding: | |
| // f'(tN) = 0 | |
| iNext = i1; | |
| tNext = 2 * t1 - t0; | |
| break; | |
| case THREE.WrapAroundEnding: | |
| // use the other end of the curve | |
| iNext = 1; | |
| tNext = t1 + pp[ 1 ] - pp[ 0 ]; | |
| break; | |
| default: // ZeroCurvatureEnding | |
| // f''(tN) = 0, a.k.a. Natural Spline | |
| iNext = i1 - 1; | |
| tNext = t0; | |
| } | |
| } | |
| var halfDt = ( t1 - t0 ) * 0.5, | |
| stride = this.valueSize; | |
| this._weightPrev = halfDt / ( t0 - tPrev ); | |
| this._weightNext = halfDt / ( tNext - t1 ); | |
| this._offsetPrev = iPrev * stride; | |
| this._offsetNext = iNext * stride; | |
| }, | |
| interpolate_: function( i1, t0, t, t1 ) { | |
| var result = this.resultBuffer, | |
| values = this.sampleValues, | |
| stride = this.valueSize, | |
| o1 = i1 * stride, o0 = o1 - stride, | |
| oP = this._offsetPrev, oN = this._offsetNext, | |
| wP = this._weightPrev, wN = this._weightNext, | |
| p = ( t - t0 ) / ( t1 - t0 ), | |
| pp = p * p, | |
| ppp = pp * p; | |
| // evaluate polynomials | |
| var sP = - wP * ppp + 2 * wP * pp - wP * p; | |
| var s0 = ( 1 + wP ) * ppp + (-1.5 - 2 * wP ) * pp + ( -0.5 + wP ) * p + 1; | |
| var s1 = (-1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p; | |
| var sN = wN * ppp - wN * pp; | |
| // combine data linearly | |
| for ( var i = 0; i !== stride; ++ i ) { | |
| result[ i ] = | |
| sP * values[ oP + i ] + | |
| s0 * values[ o0 + i ] + | |
| s1 * values[ o1 + i ] + | |
| sN * values[ oN + i ]; | |
| } | |
| return result; | |
| } | |
| } ); | |
| // File:src/math/interpolants/DiscreteInterpolant.js | |
| /** | |
| * | |
| * Interpolant that evaluates to the sample value at the position preceeding | |
| * the parameter. | |
| * | |
| * @author tschw | |
| */ | |
| THREE.DiscreteInterpolant = function( | |
| parameterPositions, sampleValues, sampleSize, resultBuffer ) { | |
| THREE.Interpolant.call( | |
| this, parameterPositions, sampleValues, sampleSize, resultBuffer ); | |
| }; | |
| THREE.DiscreteInterpolant.prototype = | |
| Object.assign( Object.create( THREE.Interpolant.prototype ), { | |
| constructor: THREE.DiscreteInterpolant, | |
| interpolate_: function( i1, t0, t, t1 ) { | |
| return this.copySampleValue_( i1 - 1 ); | |
| } | |
| } ); | |
| // File:src/math/interpolants/LinearInterpolant.js | |
| /** | |
| * @author tschw | |
| */ | |
| THREE.LinearInterpolant = function( | |
| parameterPositions, sampleValues, sampleSize, resultBuffer ) { | |
| THREE.Interpolant.call( | |
| this, parameterPositions, sampleValues, sampleSize, resultBuffer ); | |
| }; | |
| THREE.LinearInterpolant.prototype = | |
| Object.assign( Object.create( THREE.Interpolant.prototype ), { | |
| constructor: THREE.LinearInterpolant, | |
| interpolate_: function( i1, t0, t, t1 ) { | |
| var result = this.resultBuffer, | |
| values = this.sampleValues, | |
| stride = this.valueSize, | |
| offset1 = i1 * stride, | |
| offset0 = offset1 - stride, | |
| weight1 = ( t - t0 ) / ( t1 - t0 ), | |
| weight0 = 1 - weight1; | |
| for ( var i = 0; i !== stride; ++ i ) { | |
| result[ i ] = | |
| values[ offset0 + i ] * weight0 + | |
| values[ offset1 + i ] * weight1; | |
| } | |
| return result; | |
| } | |
| } ); | |
| // File:src/math/interpolants/QuaternionLinearInterpolant.js | |
| /** | |
| * Spherical linear unit quaternion interpolant. | |
| * | |
| * @author tschw | |
| */ | |
| THREE.QuaternionLinearInterpolant = function( | |
| parameterPositions, sampleValues, sampleSize, resultBuffer ) { | |
| THREE.Interpolant.call( | |
| this, parameterPositions, sampleValues, sampleSize, resultBuffer ); | |
| }; | |
| THREE.QuaternionLinearInterpolant.prototype = | |
| Object.assign( Object.create( THREE.Interpolant.prototype ), { | |
| constructor: THREE.QuaternionLinearInterpolant, | |
| interpolate_: function( i1, t0, t, t1 ) { | |
| var result = this.resultBuffer, | |
| values = this.sampleValues, | |
| stride = this.valueSize, | |
| offset = i1 * stride, | |
| alpha = ( t - t0 ) / ( t1 - t0 ); | |
| for ( var end = offset + stride; offset !== end; offset += 4 ) { | |
| THREE.Quaternion.slerpFlat( result, 0, | |
| values, offset - stride, values, offset, alpha ); | |
| } | |
| return result; | |
| } | |
| } ); | |
| // File:src/core/Clock.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Clock = function ( autoStart ) { | |
| this.autoStart = ( autoStart !== undefined ) ? autoStart : true; | |
| this.startTime = 0; | |
| this.oldTime = 0; | |
| this.elapsedTime = 0; | |
| this.running = false; | |
| }; | |
| THREE.Clock.prototype = { | |
| constructor: THREE.Clock, | |
| start: function () { | |
| this.startTime = performance.now(); | |
| this.oldTime = this.startTime; | |
| this.running = true; | |
| }, | |
| stop: function () { | |
| this.getElapsedTime(); | |
| this.running = false; | |
| }, | |
| getElapsedTime: function () { | |
| this.getDelta(); | |
| return this.elapsedTime; | |
| }, | |
| getDelta: function () { | |
| var diff = 0; | |
| if ( this.autoStart && ! this.running ) { | |
| this.start(); | |
| } | |
| if ( this.running ) { | |
| var newTime = performance.now(); | |
| diff = 0.001 * ( newTime - this.oldTime ); | |
| this.oldTime = newTime; | |
| this.elapsedTime += diff; | |
| } | |
| return diff; | |
| } | |
| }; | |
| // File:src/core/EventDispatcher.js | |
| /** | |
| * https://github.com/mrdoob/eventdispatcher.js/ | |
| */ | |
| THREE.EventDispatcher = function () {}; | |
| THREE.EventDispatcher.prototype = { | |
| constructor: THREE.EventDispatcher, | |
| apply: function ( object ) { | |
| object.addEventListener = THREE.EventDispatcher.prototype.addEventListener; | |
| object.hasEventListener = THREE.EventDispatcher.prototype.hasEventListener; | |
| object.removeEventListener = THREE.EventDispatcher.prototype.removeEventListener; | |
| object.dispatchEvent = THREE.EventDispatcher.prototype.dispatchEvent; | |
| }, | |
| addEventListener: function ( type, listener ) { | |
| if ( this._listeners === undefined ) this._listeners = {}; | |
| var listeners = this._listeners; | |
| if ( listeners[ type ] === undefined ) { | |
| listeners[ type ] = []; | |
| } | |
| if ( listeners[ type ].indexOf( listener ) === - 1 ) { | |
| listeners[ type ].push( listener ); | |
| } | |
| }, | |
| hasEventListener: function ( type, listener ) { | |
| if ( this._listeners === undefined ) return false; | |
| var listeners = this._listeners; | |
| if ( listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1 ) { | |
| return true; | |
| } | |
| return false; | |
| }, | |
| removeEventListener: function ( type, listener ) { | |
| if ( this._listeners === undefined ) return; | |
| var listeners = this._listeners; | |
| var listenerArray = listeners[ type ]; | |
| if ( listenerArray !== undefined ) { | |
| var index = listenerArray.indexOf( listener ); | |
| if ( index !== - 1 ) { | |
| listenerArray.splice( index, 1 ); | |
| } | |
| } | |
| }, | |
| dispatchEvent: function ( event ) { | |
| if ( this._listeners === undefined ) return; | |
| var listeners = this._listeners; | |
| var listenerArray = listeners[ event.type ]; | |
| if ( listenerArray !== undefined ) { | |
| event.target = this; | |
| var array = []; | |
| var length = listenerArray.length; | |
| for ( var i = 0; i < length; i ++ ) { | |
| array[ i ] = listenerArray[ i ]; | |
| } | |
| for ( var i = 0; i < length; i ++ ) { | |
| array[ i ].call( this, event ); | |
| } | |
| } | |
| } | |
| }; | |
| // File:src/core/Layers.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Layers = function () { | |
| this.mask = 1; | |
| }; | |
| THREE.Layers.prototype = { | |
| constructor: THREE.Layers, | |
| set: function ( channel ) { | |
| this.mask = 1 << channel; | |
| }, | |
| enable: function ( channel ) { | |
| this.mask |= 1 << channel; | |
| }, | |
| toggle: function ( channel ) { | |
| this.mask ^= 1 << channel; | |
| }, | |
| disable: function ( channel ) { | |
| this.mask &= ~ ( 1 << channel ); | |
| }, | |
| test: function ( layers ) { | |
| return ( this.mask & layers.mask ) !== 0; | |
| } | |
| }; | |
| // File:src/core/Raycaster.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author bhouston / http://clara.io/ | |
| * @author stephomi / http://stephaneginier.com/ | |
| */ | |
| ( function ( THREE ) { | |
| THREE.Raycaster = function ( origin, direction, near, far ) { | |
| this.ray = new THREE.Ray( origin, direction ); | |
| // direction is assumed to be normalized (for accurate distance calculations) | |
| this.near = near || 0; | |
| this.far = far || Infinity; | |
| this.params = { | |
| Mesh: {}, | |
| Line: {}, | |
| LOD: {}, | |
| Points: { threshold: 1 }, | |
| Sprite: {} | |
| }; | |
| Object.defineProperties( this.params, { | |
| PointCloud: { | |
| get: function () { | |
| console.warn( 'THREE.Raycaster: params.PointCloud has been renamed to params.Points.' ); | |
| return this.Points; | |
| } | |
| } | |
| } ); | |
| }; | |
| function ascSort( a, b ) { | |
| return a.distance - b.distance; | |
| } | |
| function intersectObject( object, raycaster, intersects, recursive ) { | |
| if ( object.visible === false ) return; | |
| object.raycast( raycaster, intersects ); | |
| if ( recursive === true ) { | |
| var children = object.children; | |
| for ( var i = 0, l = children.length; i < l; i ++ ) { | |
| intersectObject( children[ i ], raycaster, intersects, true ); | |
| } | |
| } | |
| } | |
| // | |
| THREE.Raycaster.prototype = { | |
| constructor: THREE.Raycaster, | |
| linePrecision: 1, | |
| set: function ( origin, direction ) { | |
| // direction is assumed to be normalized (for accurate distance calculations) | |
| this.ray.set( origin, direction ); | |
| }, | |
| setFromCamera: function ( coords, camera ) { | |
| if ( camera instanceof THREE.PerspectiveCamera ) { | |
| this.ray.origin.setFromMatrixPosition( camera.matrixWorld ); | |
| this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize(); | |
| } else if ( camera instanceof THREE.OrthographicCamera ) { | |
| this.ray.origin.set( coords.x, coords.y, - 1 ).unproject( camera ); | |
| this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld ); | |
| } else { | |
| console.error( 'THREE.Raycaster: Unsupported camera type.' ); | |
| } | |
| }, | |
| intersectObject: function ( object, recursive ) { | |
| var intersects = []; | |
| intersectObject( object, this, intersects, recursive ); | |
| intersects.sort( ascSort ); | |
| return intersects; | |
| }, | |
| intersectObjects: function ( objects, recursive ) { | |
| var intersects = []; | |
| if ( Array.isArray( objects ) === false ) { | |
| console.warn( 'THREE.Raycaster.intersectObjects: objects is not an Array.' ); | |
| return intersects; | |
| } | |
| for ( var i = 0, l = objects.length; i < l; i ++ ) { | |
| intersectObject( objects[ i ], this, intersects, recursive ); | |
| } | |
| intersects.sort( ascSort ); | |
| return intersects; | |
| } | |
| }; | |
| }( THREE ) ); | |
| // File:src/core/Object3D.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author WestLangley / http://github.com/WestLangley | |
| * @author elephantatwork / www.elephantatwork.ch | |
| */ | |
| THREE.Object3D = function () { | |
| Object.defineProperty( this, 'id', { value: THREE.Object3DIdCount ++ } ); | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.name = ''; | |
| this.type = 'Object3D'; | |
| this.parent = null; | |
| this.children = []; | |
| this.up = THREE.Object3D.DefaultUp.clone(); | |
| var position = new THREE.Vector3(); | |
| var rotation = new THREE.Euler(); | |
| var quaternion = new THREE.Quaternion(); | |
| var scale = new THREE.Vector3( 1, 1, 1 ); | |
| function onRotationChange() { | |
| quaternion.setFromEuler( rotation, false ); | |
| } | |
| function onQuaternionChange() { | |
| rotation.setFromQuaternion( quaternion, undefined, false ); | |
| } | |
| rotation.onChange( onRotationChange ); | |
| quaternion.onChange( onQuaternionChange ); | |
| Object.defineProperties( this, { | |
| position: { | |
| enumerable: true, | |
| value: position | |
| }, | |
| rotation: { | |
| enumerable: true, | |
| value: rotation | |
| }, | |
| quaternion: { | |
| enumerable: true, | |
| value: quaternion | |
| }, | |
| scale: { | |
| enumerable: true, | |
| value: scale | |
| }, | |
| modelViewMatrix: { | |
| value: new THREE.Matrix4() | |
| }, | |
| normalMatrix: { | |
| value: new THREE.Matrix3() | |
| } | |
| } ); | |
| this.rotationAutoUpdate = true; | |
| this.matrix = new THREE.Matrix4(); | |
| this.matrixWorld = new THREE.Matrix4(); | |
| this.matrixAutoUpdate = THREE.Object3D.DefaultMatrixAutoUpdate; | |
| this.matrixWorldNeedsUpdate = false; | |
| this.layers = new THREE.Layers(); | |
| this.visible = true; | |
| this.castShadow = false; | |
| this.receiveShadow = false; | |
| this.frustumCulled = true; | |
| this.renderOrder = 0; | |
| this.userData = {}; | |
| }; | |
| THREE.Object3D.DefaultUp = new THREE.Vector3( 0, 1, 0 ); | |
| THREE.Object3D.DefaultMatrixAutoUpdate = true; | |
| THREE.Object3D.prototype = { | |
| constructor: THREE.Object3D, | |
| applyMatrix: function ( matrix ) { | |
| this.matrix.multiplyMatrices( matrix, this.matrix ); | |
| this.matrix.decompose( this.position, this.quaternion, this.scale ); | |
| }, | |
| setRotationFromAxisAngle: function ( axis, angle ) { | |
| // assumes axis is normalized | |
| this.quaternion.setFromAxisAngle( axis, angle ); | |
| }, | |
| setRotationFromEuler: function ( euler ) { | |
| this.quaternion.setFromEuler( euler, true ); | |
| }, | |
| setRotationFromMatrix: function ( m ) { | |
| // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) | |
| this.quaternion.setFromRotationMatrix( m ); | |
| }, | |
| setRotationFromQuaternion: function ( q ) { | |
| // assumes q is normalized | |
| this.quaternion.copy( q ); | |
| }, | |
| rotateOnAxis: function () { | |
| // rotate object on axis in object space | |
| // axis is assumed to be normalized | |
| var q1 = new THREE.Quaternion(); | |
| return function ( axis, angle ) { | |
| q1.setFromAxisAngle( axis, angle ); | |
| this.quaternion.multiply( q1 ); | |
| return this; | |
| }; | |
| }(), | |
| rotateX: function () { | |
| var v1 = new THREE.Vector3( 1, 0, 0 ); | |
| return function ( angle ) { | |
| return this.rotateOnAxis( v1, angle ); | |
| }; | |
| }(), | |
| rotateY: function () { | |
| var v1 = new THREE.Vector3( 0, 1, 0 ); | |
| return function ( angle ) { | |
| return this.rotateOnAxis( v1, angle ); | |
| }; | |
| }(), | |
| rotateZ: function () { | |
| var v1 = new THREE.Vector3( 0, 0, 1 ); | |
| return function ( angle ) { | |
| return this.rotateOnAxis( v1, angle ); | |
| }; | |
| }(), | |
| translateOnAxis: function () { | |
| // translate object by distance along axis in object space | |
| // axis is assumed to be normalized | |
| var v1 = new THREE.Vector3(); | |
| return function ( axis, distance ) { | |
| v1.copy( axis ).applyQuaternion( this.quaternion ); | |
| this.position.add( v1.multiplyScalar( distance ) ); | |
| return this; | |
| }; | |
| }(), | |
| translateX: function () { | |
| var v1 = new THREE.Vector3( 1, 0, 0 ); | |
| return function ( distance ) { | |
| return this.translateOnAxis( v1, distance ); | |
| }; | |
| }(), | |
| translateY: function () { | |
| var v1 = new THREE.Vector3( 0, 1, 0 ); | |
| return function ( distance ) { | |
| return this.translateOnAxis( v1, distance ); | |
| }; | |
| }(), | |
| translateZ: function () { | |
| var v1 = new THREE.Vector3( 0, 0, 1 ); | |
| return function ( distance ) { | |
| return this.translateOnAxis( v1, distance ); | |
| }; | |
| }(), | |
| localToWorld: function ( vector ) { | |
| return vector.applyMatrix4( this.matrixWorld ); | |
| }, | |
| worldToLocal: function () { | |
| var m1 = new THREE.Matrix4(); | |
| return function ( vector ) { | |
| return vector.applyMatrix4( m1.getInverse( this.matrixWorld ) ); | |
| }; | |
| }(), | |
| lookAt: function () { | |
| // This routine does not support objects with rotated and/or translated parent(s) | |
| var m1 = new THREE.Matrix4(); | |
| return function ( vector ) { | |
| m1.lookAt( vector, this.position, this.up ); | |
| this.quaternion.setFromRotationMatrix( m1 ); | |
| }; | |
| }(), | |
| add: function ( object ) { | |
| if ( arguments.length > 1 ) { | |
| for ( var i = 0; i < arguments.length; i ++ ) { | |
| this.add( arguments[ i ] ); | |
| } | |
| return this; | |
| } | |
| if ( object === this ) { | |
| console.error( "THREE.Object3D.add: object can't be added as a child of itself.", object ); | |
| return this; | |
| } | |
| if ( object instanceof THREE.Object3D ) { | |
| if ( object.parent !== null ) { | |
| object.parent.remove( object ); | |
| } | |
| object.parent = this; | |
| object.dispatchEvent( { type: 'added' } ); | |
| this.children.push( object ); | |
| } else { | |
| console.error( "THREE.Object3D.add: object not an instance of THREE.Object3D.", object ); | |
| } | |
| return this; | |
| }, | |
| remove: function ( object ) { | |
| if ( arguments.length > 1 ) { | |
| for ( var i = 0; i < arguments.length; i ++ ) { | |
| this.remove( arguments[ i ] ); | |
| } | |
| } | |
| var index = this.children.indexOf( object ); | |
| if ( index !== - 1 ) { | |
| object.parent = null; | |
| object.dispatchEvent( { type: 'removed' } ); | |
| this.children.splice( index, 1 ); | |
| } | |
| }, | |
| getObjectById: function ( id ) { | |
| return this.getObjectByProperty( 'id', id ); | |
| }, | |
| getObjectByName: function ( name ) { | |
| return this.getObjectByProperty( 'name', name ); | |
| }, | |
| getObjectByProperty: function ( name, value ) { | |
| if ( this[ name ] === value ) return this; | |
| for ( var i = 0, l = this.children.length; i < l; i ++ ) { | |
| var child = this.children[ i ]; | |
| var object = child.getObjectByProperty( name, value ); | |
| if ( object !== undefined ) { | |
| return object; | |
| } | |
| } | |
| return undefined; | |
| }, | |
| getWorldPosition: function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| this.updateMatrixWorld( true ); | |
| return result.setFromMatrixPosition( this.matrixWorld ); | |
| }, | |
| getWorldQuaternion: function () { | |
| var position = new THREE.Vector3(); | |
| var scale = new THREE.Vector3(); | |
| return function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Quaternion(); | |
| this.updateMatrixWorld( true ); | |
| this.matrixWorld.decompose( position, result, scale ); | |
| return result; | |
| }; | |
| }(), | |
| getWorldRotation: function () { | |
| var quaternion = new THREE.Quaternion(); | |
| return function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Euler(); | |
| this.getWorldQuaternion( quaternion ); | |
| return result.setFromQuaternion( quaternion, this.rotation.order, false ); | |
| }; | |
| }(), | |
| getWorldScale: function () { | |
| var position = new THREE.Vector3(); | |
| var quaternion = new THREE.Quaternion(); | |
| return function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| this.updateMatrixWorld( true ); | |
| this.matrixWorld.decompose( position, quaternion, result ); | |
| return result; | |
| }; | |
| }(), | |
| getWorldDirection: function () { | |
| var quaternion = new THREE.Quaternion(); | |
| return function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| this.getWorldQuaternion( quaternion ); | |
| return result.set( 0, 0, 1 ).applyQuaternion( quaternion ); | |
| }; | |
| }(), | |
| raycast: function () {}, | |
| traverse: function ( callback ) { | |
| callback( this ); | |
| var children = this.children; | |
| for ( var i = 0, l = children.length; i < l; i ++ ) { | |
| children[ i ].traverse( callback ); | |
| } | |
| }, | |
| traverseVisible: function ( callback ) { | |
| if ( this.visible === false ) return; | |
| callback( this ); | |
| var children = this.children; | |
| for ( var i = 0, l = children.length; i < l; i ++ ) { | |
| children[ i ].traverseVisible( callback ); | |
| } | |
| }, | |
| traverseAncestors: function ( callback ) { | |
| var parent = this.parent; | |
| if ( parent !== null ) { | |
| callback( parent ); | |
| parent.traverseAncestors( callback ); | |
| } | |
| }, | |
| updateMatrix: function () { | |
| this.matrix.compose( this.position, this.quaternion, this.scale ); | |
| this.matrixWorldNeedsUpdate = true; | |
| }, | |
| updateMatrixWorld: function ( force ) { | |
| if ( this.matrixAutoUpdate === true ) this.updateMatrix(); | |
| if ( this.matrixWorldNeedsUpdate === true || force === true ) { | |
| if ( this.parent === null ) { | |
| this.matrixWorld.copy( this.matrix ); | |
| } else { | |
| this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix ); | |
| } | |
| this.matrixWorldNeedsUpdate = false; | |
| force = true; | |
| } | |
| // update children | |
| for ( var i = 0, l = this.children.length; i < l; i ++ ) { | |
| this.children[ i ].updateMatrixWorld( force ); | |
| } | |
| }, | |
| toJSON: function ( meta ) { | |
| var isRootObject = ( meta === undefined ); | |
| var output = {}; | |
| // meta is a hash used to collect geometries, materials. | |
| // not providing it implies that this is the root object | |
| // being serialized. | |
| if ( isRootObject ) { | |
| // initialize meta obj | |
| meta = { | |
| geometries: {}, | |
| materials: {}, | |
| textures: {}, | |
| images: {} | |
| }; | |
| output.metadata = { | |
| version: 4.4, | |
| type: 'Object', | |
| generator: 'Object3D.toJSON' | |
| }; | |
| } | |
| // standard Object3D serialization | |
| var object = {}; | |
| object.uuid = this.uuid; | |
| object.type = this.type; | |
| if ( this.name !== '' ) object.name = this.name; | |
| if ( JSON.stringify( this.userData ) !== '{}' ) object.userData = this.userData; | |
| if ( this.castShadow === true ) object.castShadow = true; | |
| if ( this.receiveShadow === true ) object.receiveShadow = true; | |
| if ( this.visible === false ) object.visible = false; | |
| object.matrix = this.matrix.toArray(); | |
| // | |
| if ( this.geometry !== undefined ) { | |
| if ( meta.geometries[ this.geometry.uuid ] === undefined ) { | |
| meta.geometries[ this.geometry.uuid ] = this.geometry.toJSON( meta ); | |
| } | |
| object.geometry = this.geometry.uuid; | |
| } | |
| if ( this.material !== undefined ) { | |
| if ( meta.materials[ this.material.uuid ] === undefined ) { | |
| meta.materials[ this.material.uuid ] = this.material.toJSON( meta ); | |
| } | |
| object.material = this.material.uuid; | |
| } | |
| // | |
| if ( this.children.length > 0 ) { | |
| object.children = []; | |
| for ( var i = 0; i < this.children.length; i ++ ) { | |
| object.children.push( this.children[ i ].toJSON( meta ).object ); | |
| } | |
| } | |
| if ( isRootObject ) { | |
| var geometries = extractFromCache( meta.geometries ); | |
| var materials = extractFromCache( meta.materials ); | |
| var textures = extractFromCache( meta.textures ); | |
| var images = extractFromCache( meta.images ); | |
| if ( geometries.length > 0 ) output.geometries = geometries; | |
| if ( materials.length > 0 ) output.materials = materials; | |
| if ( textures.length > 0 ) output.textures = textures; | |
| if ( images.length > 0 ) output.images = images; | |
| } | |
| output.object = object; | |
| return output; | |
| // extract data from the cache hash | |
| // remove metadata on each item | |
| // and return as array | |
| function extractFromCache ( cache ) { | |
| var values = []; | |
| for ( var key in cache ) { | |
| var data = cache[ key ]; | |
| delete data.metadata; | |
| values.push( data ); | |
| } | |
| return values; | |
| } | |
| }, | |
| clone: function ( recursive ) { | |
| return new this.constructor().copy( this, recursive ); | |
| }, | |
| copy: function ( source, recursive ) { | |
| if ( recursive === undefined ) recursive = true; | |
| this.name = source.name; | |
| this.up.copy( source.up ); | |
| this.position.copy( source.position ); | |
| this.quaternion.copy( source.quaternion ); | |
| this.scale.copy( source.scale ); | |
| this.rotationAutoUpdate = source.rotationAutoUpdate; | |
| this.matrix.copy( source.matrix ); | |
| this.matrixWorld.copy( source.matrixWorld ); | |
| this.matrixAutoUpdate = source.matrixAutoUpdate; | |
| this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate; | |
| this.visible = source.visible; | |
| this.castShadow = source.castShadow; | |
| this.receiveShadow = source.receiveShadow; | |
| this.frustumCulled = source.frustumCulled; | |
| this.renderOrder = source.renderOrder; | |
| this.userData = JSON.parse( JSON.stringify( source.userData ) ); | |
| if ( recursive === true ) { | |
| for ( var i = 0; i < source.children.length; i ++ ) { | |
| var child = source.children[ i ]; | |
| this.add( child.clone() ); | |
| } | |
| } | |
| return this; | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.Object3D.prototype ); | |
| THREE.Object3DIdCount = 0; | |
| // File:src/core/Face3.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Face3 = function ( a, b, c, normal, color, materialIndex ) { | |
| this.a = a; | |
| this.b = b; | |
| this.c = c; | |
| this.normal = normal instanceof THREE.Vector3 ? normal : new THREE.Vector3(); | |
| this.vertexNormals = Array.isArray( normal ) ? normal : []; | |
| this.color = color instanceof THREE.Color ? color : new THREE.Color(); | |
| this.vertexColors = Array.isArray( color ) ? color : []; | |
| this.materialIndex = materialIndex !== undefined ? materialIndex : 0; | |
| }; | |
| THREE.Face3.prototype = { | |
| constructor: THREE.Face3, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( source ) { | |
| this.a = source.a; | |
| this.b = source.b; | |
| this.c = source.c; | |
| this.normal.copy( source.normal ); | |
| this.color.copy( source.color ); | |
| this.materialIndex = source.materialIndex; | |
| for ( var i = 0, il = source.vertexNormals.length; i < il; i ++ ) { | |
| this.vertexNormals[ i ] = source.vertexNormals[ i ].clone(); | |
| } | |
| for ( var i = 0, il = source.vertexColors.length; i < il; i ++ ) { | |
| this.vertexColors[ i ] = source.vertexColors[ i ].clone(); | |
| } | |
| return this; | |
| } | |
| }; | |
| // File:src/core/BufferAttribute.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.BufferAttribute = function ( array, itemSize ) { | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.array = array; | |
| this.itemSize = itemSize; | |
| this.dynamic = false; | |
| this.updateRange = { offset: 0, count: - 1 }; | |
| this.version = 0; | |
| }; | |
| THREE.BufferAttribute.prototype = { | |
| constructor: THREE.BufferAttribute, | |
| get count() { | |
| return this.array.length / this.itemSize; | |
| }, | |
| set needsUpdate( value ) { | |
| if ( value === true ) this.version ++; | |
| }, | |
| setDynamic: function ( value ) { | |
| this.dynamic = value; | |
| return this; | |
| }, | |
| copy: function ( source ) { | |
| this.array = new source.array.constructor( source.array ); | |
| this.itemSize = source.itemSize; | |
| this.dynamic = source.dynamic; | |
| return this; | |
| }, | |
| copyAt: function ( index1, attribute, index2 ) { | |
| index1 *= this.itemSize; | |
| index2 *= attribute.itemSize; | |
| for ( var i = 0, l = this.itemSize; i < l; i ++ ) { | |
| this.array[ index1 + i ] = attribute.array[ index2 + i ]; | |
| } | |
| return this; | |
| }, | |
| copyArray: function ( array ) { | |
| this.array.set( array ); | |
| return this; | |
| }, | |
| copyColorsArray: function ( colors ) { | |
| var array = this.array, offset = 0; | |
| for ( var i = 0, l = colors.length; i < l; i ++ ) { | |
| var color = colors[ i ]; | |
| if ( color === undefined ) { | |
| console.warn( 'THREE.BufferAttribute.copyColorsArray(): color is undefined', i ); | |
| color = new THREE.Color(); | |
| } | |
| array[ offset ++ ] = color.r; | |
| array[ offset ++ ] = color.g; | |
| array[ offset ++ ] = color.b; | |
| } | |
| return this; | |
| }, | |
| copyIndicesArray: function ( indices ) { | |
| var array = this.array, offset = 0; | |
| for ( var i = 0, l = indices.length; i < l; i ++ ) { | |
| var index = indices[ i ]; | |
| array[ offset ++ ] = index.a; | |
| array[ offset ++ ] = index.b; | |
| array[ offset ++ ] = index.c; | |
| } | |
| return this; | |
| }, | |
| copyVector2sArray: function ( vectors ) { | |
| var array = this.array, offset = 0; | |
| for ( var i = 0, l = vectors.length; i < l; i ++ ) { | |
| var vector = vectors[ i ]; | |
| if ( vector === undefined ) { | |
| console.warn( 'THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i ); | |
| vector = new THREE.Vector2(); | |
| } | |
| array[ offset ++ ] = vector.x; | |
| array[ offset ++ ] = vector.y; | |
| } | |
| return this; | |
| }, | |
| copyVector3sArray: function ( vectors ) { | |
| var array = this.array, offset = 0; | |
| for ( var i = 0, l = vectors.length; i < l; i ++ ) { | |
| var vector = vectors[ i ]; | |
| if ( vector === undefined ) { | |
| console.warn( 'THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i ); | |
| vector = new THREE.Vector3(); | |
| } | |
| array[ offset ++ ] = vector.x; | |
| array[ offset ++ ] = vector.y; | |
| array[ offset ++ ] = vector.z; | |
| } | |
| return this; | |
| }, | |
| copyVector4sArray: function ( vectors ) { | |
| var array = this.array, offset = 0; | |
| for ( var i = 0, l = vectors.length; i < l; i ++ ) { | |
| var vector = vectors[ i ]; | |
| if ( vector === undefined ) { | |
| console.warn( 'THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i ); | |
| vector = new THREE.Vector4(); | |
| } | |
| array[ offset ++ ] = vector.x; | |
| array[ offset ++ ] = vector.y; | |
| array[ offset ++ ] = vector.z; | |
| array[ offset ++ ] = vector.w; | |
| } | |
| return this; | |
| }, | |
| set: function ( value, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| this.array.set( value, offset ); | |
| return this; | |
| }, | |
| getX: function ( index ) { | |
| return this.array[ index * this.itemSize ]; | |
| }, | |
| setX: function ( index, x ) { | |
| this.array[ index * this.itemSize ] = x; | |
| return this; | |
| }, | |
| getY: function ( index ) { | |
| return this.array[ index * this.itemSize + 1 ]; | |
| }, | |
| setY: function ( index, y ) { | |
| this.array[ index * this.itemSize + 1 ] = y; | |
| return this; | |
| }, | |
| getZ: function ( index ) { | |
| return this.array[ index * this.itemSize + 2 ]; | |
| }, | |
| setZ: function ( index, z ) { | |
| this.array[ index * this.itemSize + 2 ] = z; | |
| return this; | |
| }, | |
| getW: function ( index ) { | |
| return this.array[ index * this.itemSize + 3 ]; | |
| }, | |
| setW: function ( index, w ) { | |
| this.array[ index * this.itemSize + 3 ] = w; | |
| return this; | |
| }, | |
| setXY: function ( index, x, y ) { | |
| index *= this.itemSize; | |
| this.array[ index + 0 ] = x; | |
| this.array[ index + 1 ] = y; | |
| return this; | |
| }, | |
| setXYZ: function ( index, x, y, z ) { | |
| index *= this.itemSize; | |
| this.array[ index + 0 ] = x; | |
| this.array[ index + 1 ] = y; | |
| this.array[ index + 2 ] = z; | |
| return this; | |
| }, | |
| setXYZW: function ( index, x, y, z, w ) { | |
| index *= this.itemSize; | |
| this.array[ index + 0 ] = x; | |
| this.array[ index + 1 ] = y; | |
| this.array[ index + 2 ] = z; | |
| this.array[ index + 3 ] = w; | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| } | |
| }; | |
| // | |
| THREE.Int8Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Int8Array( array ), itemSize ); | |
| }; | |
| THREE.Uint8Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Uint8Array( array ), itemSize ); | |
| }; | |
| THREE.Uint8ClampedAttribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Uint8ClampedArray( array ), itemSize ); | |
| }; | |
| THREE.Int16Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Int16Array( array ), itemSize ); | |
| }; | |
| THREE.Uint16Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Uint16Array( array ), itemSize ); | |
| }; | |
| THREE.Int32Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Int32Array( array ), itemSize ); | |
| }; | |
| THREE.Uint32Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Uint32Array( array ), itemSize ); | |
| }; | |
| THREE.Float32Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Float32Array( array ), itemSize ); | |
| }; | |
| THREE.Float64Attribute = function ( array, itemSize ) { | |
| return new THREE.BufferAttribute( new Float64Array( array ), itemSize ); | |
| }; | |
| // Deprecated | |
| THREE.DynamicBufferAttribute = function ( array, itemSize ) { | |
| console.warn( 'THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.' ); | |
| return new THREE.BufferAttribute( array, itemSize ).setDynamic( true ); | |
| }; | |
| // File:src/core/InstancedBufferAttribute.js | |
| /** | |
| * @author benaadams / https://twitter.com/ben_a_adams | |
| */ | |
| THREE.InstancedBufferAttribute = function ( array, itemSize, meshPerAttribute ) { | |
| THREE.BufferAttribute.call( this, array, itemSize ); | |
| this.meshPerAttribute = meshPerAttribute || 1; | |
| }; | |
| THREE.InstancedBufferAttribute.prototype = Object.create( THREE.BufferAttribute.prototype ); | |
| THREE.InstancedBufferAttribute.prototype.constructor = THREE.InstancedBufferAttribute; | |
| THREE.InstancedBufferAttribute.prototype.copy = function ( source ) { | |
| THREE.BufferAttribute.prototype.copy.call( this, source ); | |
| this.meshPerAttribute = source.meshPerAttribute; | |
| return this; | |
| }; | |
| // File:src/core/InterleavedBuffer.js | |
| /** | |
| * @author benaadams / https://twitter.com/ben_a_adams | |
| */ | |
| THREE.InterleavedBuffer = function ( array, stride ) { | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.array = array; | |
| this.stride = stride; | |
| this.dynamic = false; | |
| this.updateRange = { offset: 0, count: - 1 }; | |
| this.version = 0; | |
| }; | |
| THREE.InterleavedBuffer.prototype = { | |
| constructor: THREE.InterleavedBuffer, | |
| get length () { | |
| return this.array.length; | |
| }, | |
| get count () { | |
| return this.array.length / this.stride; | |
| }, | |
| set needsUpdate( value ) { | |
| if ( value === true ) this.version ++; | |
| }, | |
| setDynamic: function ( value ) { | |
| this.dynamic = value; | |
| return this; | |
| }, | |
| copy: function ( source ) { | |
| this.array = new source.array.constructor( source.array ); | |
| this.stride = source.stride; | |
| this.dynamic = source.dynamic; | |
| return this; | |
| }, | |
| copyAt: function ( index1, attribute, index2 ) { | |
| index1 *= this.stride; | |
| index2 *= attribute.stride; | |
| for ( var i = 0, l = this.stride; i < l; i ++ ) { | |
| this.array[ index1 + i ] = attribute.array[ index2 + i ]; | |
| } | |
| return this; | |
| }, | |
| set: function ( value, offset ) { | |
| if ( offset === undefined ) offset = 0; | |
| this.array.set( value, offset ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| } | |
| }; | |
| // File:src/core/InstancedInterleavedBuffer.js | |
| /** | |
| * @author benaadams / https://twitter.com/ben_a_adams | |
| */ | |
| THREE.InstancedInterleavedBuffer = function ( array, stride, meshPerAttribute ) { | |
| THREE.InterleavedBuffer.call( this, array, stride ); | |
| this.meshPerAttribute = meshPerAttribute || 1; | |
| }; | |
| THREE.InstancedInterleavedBuffer.prototype = Object.create( THREE.InterleavedBuffer.prototype ); | |
| THREE.InstancedInterleavedBuffer.prototype.constructor = THREE.InstancedInterleavedBuffer; | |
| THREE.InstancedInterleavedBuffer.prototype.copy = function ( source ) { | |
| THREE.InterleavedBuffer.prototype.copy.call( this, source ); | |
| this.meshPerAttribute = source.meshPerAttribute; | |
| return this; | |
| }; | |
| // File:src/core/InterleavedBufferAttribute.js | |
| /** | |
| * @author benaadams / https://twitter.com/ben_a_adams | |
| */ | |
| THREE.InterleavedBufferAttribute = function ( interleavedBuffer, itemSize, offset ) { | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.data = interleavedBuffer; | |
| this.itemSize = itemSize; | |
| this.offset = offset; | |
| }; | |
| THREE.InterleavedBufferAttribute.prototype = { | |
| constructor: THREE.InterleavedBufferAttribute, | |
| get length() { | |
| console.warn( 'THREE.BufferAttribute: .length has been deprecated. Please use .count.' ); | |
| return this.array.length; | |
| }, | |
| get count() { | |
| return this.data.count; | |
| }, | |
| setX: function ( index, x ) { | |
| this.data.array[ index * this.data.stride + this.offset ] = x; | |
| return this; | |
| }, | |
| setY: function ( index, y ) { | |
| this.data.array[ index * this.data.stride + this.offset + 1 ] = y; | |
| return this; | |
| }, | |
| setZ: function ( index, z ) { | |
| this.data.array[ index * this.data.stride + this.offset + 2 ] = z; | |
| return this; | |
| }, | |
| setW: function ( index, w ) { | |
| this.data.array[ index * this.data.stride + this.offset + 3 ] = w; | |
| return this; | |
| }, | |
| getX: function ( index ) { | |
| return this.data.array[ index * this.data.stride + this.offset ]; | |
| }, | |
| getY: function ( index ) { | |
| return this.data.array[ index * this.data.stride + this.offset + 1 ]; | |
| }, | |
| getZ: function ( index ) { | |
| return this.data.array[ index * this.data.stride + this.offset + 2 ]; | |
| }, | |
| getW: function ( index ) { | |
| return this.data.array[ index * this.data.stride + this.offset + 3 ]; | |
| }, | |
| setXY: function ( index, x, y ) { | |
| index = index * this.data.stride + this.offset; | |
| this.data.array[ index + 0 ] = x; | |
| this.data.array[ index + 1 ] = y; | |
| return this; | |
| }, | |
| setXYZ: function ( index, x, y, z ) { | |
| index = index * this.data.stride + this.offset; | |
| this.data.array[ index + 0 ] = x; | |
| this.data.array[ index + 1 ] = y; | |
| this.data.array[ index + 2 ] = z; | |
| return this; | |
| }, | |
| setXYZW: function ( index, x, y, z, w ) { | |
| index = index * this.data.stride + this.offset; | |
| this.data.array[ index + 0 ] = x; | |
| this.data.array[ index + 1 ] = y; | |
| this.data.array[ index + 2 ] = z; | |
| this.data.array[ index + 3 ] = w; | |
| return this; | |
| } | |
| }; | |
| // File:src/core/Geometry.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author kile / http://kile.stravaganza.org/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author zz85 / http://www.lab4games.net/zz85/blog | |
| * @author bhouston / http://clara.io | |
| */ | |
| THREE.Geometry = function () { | |
| Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } ); | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.name = ''; | |
| this.type = 'Geometry'; | |
| this.vertices = []; | |
| this.colors = []; | |
| this.faces = []; | |
| this.faceVertexUvs = [ [] ]; | |
| this.morphTargets = []; | |
| this.morphNormals = []; | |
| this.skinWeights = []; | |
| this.skinIndices = []; | |
| this.lineDistances = []; | |
| this.boundingBox = null; | |
| this.boundingSphere = null; | |
| // update flags | |
| this.verticesNeedUpdate = false; | |
| this.elementsNeedUpdate = false; | |
| this.uvsNeedUpdate = false; | |
| this.normalsNeedUpdate = false; | |
| this.colorsNeedUpdate = false; | |
| this.lineDistancesNeedUpdate = false; | |
| this.groupsNeedUpdate = false; | |
| }; | |
| THREE.Geometry.prototype = { | |
| constructor: THREE.Geometry, | |
| applyMatrix: function ( matrix ) { | |
| var normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix ); | |
| for ( var i = 0, il = this.vertices.length; i < il; i ++ ) { | |
| var vertex = this.vertices[ i ]; | |
| vertex.applyMatrix4( matrix ); | |
| } | |
| for ( var i = 0, il = this.faces.length; i < il; i ++ ) { | |
| var face = this.faces[ i ]; | |
| face.normal.applyMatrix3( normalMatrix ).normalize(); | |
| for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) { | |
| face.vertexNormals[ j ].applyMatrix3( normalMatrix ).normalize(); | |
| } | |
| } | |
| if ( this.boundingBox !== null ) { | |
| this.computeBoundingBox(); | |
| } | |
| if ( this.boundingSphere !== null ) { | |
| this.computeBoundingSphere(); | |
| } | |
| this.verticesNeedUpdate = true; | |
| this.normalsNeedUpdate = true; | |
| }, | |
| rotateX: function () { | |
| // rotate geometry around world x-axis | |
| var m1; | |
| return function rotateX( angle ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeRotationX( angle ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| rotateY: function () { | |
| // rotate geometry around world y-axis | |
| var m1; | |
| return function rotateY( angle ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeRotationY( angle ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| rotateZ: function () { | |
| // rotate geometry around world z-axis | |
| var m1; | |
| return function rotateZ( angle ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeRotationZ( angle ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| translate: function () { | |
| // translate geometry | |
| var m1; | |
| return function translate( x, y, z ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeTranslation( x, y, z ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| scale: function () { | |
| // scale geometry | |
| var m1; | |
| return function scale( x, y, z ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeScale( x, y, z ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| lookAt: function () { | |
| var obj; | |
| return function lookAt( vector ) { | |
| if ( obj === undefined ) obj = new THREE.Object3D(); | |
| obj.lookAt( vector ); | |
| obj.updateMatrix(); | |
| this.applyMatrix( obj.matrix ); | |
| }; | |
| }(), | |
| fromBufferGeometry: function ( geometry ) { | |
| var scope = this; | |
| var indices = geometry.index !== null ? geometry.index.array : undefined; | |
| var attributes = geometry.attributes; | |
| var positions = attributes.position.array; | |
| var normals = attributes.normal !== undefined ? attributes.normal.array : undefined; | |
| var colors = attributes.color !== undefined ? attributes.color.array : undefined; | |
| var uvs = attributes.uv !== undefined ? attributes.uv.array : undefined; | |
| var uvs2 = attributes.uv2 !== undefined ? attributes.uv2.array : undefined; | |
| if ( uvs2 !== undefined ) this.faceVertexUvs[ 1 ] = []; | |
| var tempNormals = []; | |
| var tempUVs = []; | |
| var tempUVs2 = []; | |
| for ( var i = 0, j = 0; i < positions.length; i += 3, j += 2 ) { | |
| scope.vertices.push( new THREE.Vector3( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] ) ); | |
| if ( normals !== undefined ) { | |
| tempNormals.push( new THREE.Vector3( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] ) ); | |
| } | |
| if ( colors !== undefined ) { | |
| scope.colors.push( new THREE.Color( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] ) ); | |
| } | |
| if ( uvs !== undefined ) { | |
| tempUVs.push( new THREE.Vector2( uvs[ j ], uvs[ j + 1 ] ) ); | |
| } | |
| if ( uvs2 !== undefined ) { | |
| tempUVs2.push( new THREE.Vector2( uvs2[ j ], uvs2[ j + 1 ] ) ); | |
| } | |
| } | |
| function addFace( a, b, c ) { | |
| var vertexNormals = normals !== undefined ? [ tempNormals[ a ].clone(), tempNormals[ b ].clone(), tempNormals[ c ].clone() ] : []; | |
| var vertexColors = colors !== undefined ? [ scope.colors[ a ].clone(), scope.colors[ b ].clone(), scope.colors[ c ].clone() ] : []; | |
| var face = new THREE.Face3( a, b, c, vertexNormals, vertexColors ); | |
| scope.faces.push( face ); | |
| if ( uvs !== undefined ) { | |
| scope.faceVertexUvs[ 0 ].push( [ tempUVs[ a ].clone(), tempUVs[ b ].clone(), tempUVs[ c ].clone() ] ); | |
| } | |
| if ( uvs2 !== undefined ) { | |
| scope.faceVertexUvs[ 1 ].push( [ tempUVs2[ a ].clone(), tempUVs2[ b ].clone(), tempUVs2[ c ].clone() ] ); | |
| } | |
| } | |
| if ( indices !== undefined ) { | |
| var groups = geometry.groups; | |
| if ( groups.length > 0 ) { | |
| for ( var i = 0; i < groups.length; i ++ ) { | |
| var group = groups[ i ]; | |
| var start = group.start; | |
| var count = group.count; | |
| for ( var j = start, jl = start + count; j < jl; j += 3 ) { | |
| addFace( indices[ j ], indices[ j + 1 ], indices[ j + 2 ] ); | |
| } | |
| } | |
| } else { | |
| for ( var i = 0; i < indices.length; i += 3 ) { | |
| addFace( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] ); | |
| } | |
| } | |
| } else { | |
| for ( var i = 0; i < positions.length / 3; i += 3 ) { | |
| addFace( i, i + 1, i + 2 ); | |
| } | |
| } | |
| this.computeFaceNormals(); | |
| if ( geometry.boundingBox !== null ) { | |
| this.boundingBox = geometry.boundingBox.clone(); | |
| } | |
| if ( geometry.boundingSphere !== null ) { | |
| this.boundingSphere = geometry.boundingSphere.clone(); | |
| } | |
| return this; | |
| }, | |
| center: function () { | |
| this.computeBoundingBox(); | |
| var offset = this.boundingBox.center().negate(); | |
| this.translate( offset.x, offset.y, offset.z ); | |
| return offset; | |
| }, | |
| normalize: function () { | |
| this.computeBoundingSphere(); | |
| var center = this.boundingSphere.center; | |
| var radius = this.boundingSphere.radius; | |
| var s = radius === 0 ? 1 : 1.0 / radius; | |
| var matrix = new THREE.Matrix4(); | |
| matrix.set( | |
| s, 0, 0, - s * center.x, | |
| 0, s, 0, - s * center.y, | |
| 0, 0, s, - s * center.z, | |
| 0, 0, 0, 1 | |
| ); | |
| this.applyMatrix( matrix ); | |
| return this; | |
| }, | |
| computeFaceNormals: function () { | |
| var cb = new THREE.Vector3(), ab = new THREE.Vector3(); | |
| for ( var f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| var face = this.faces[ f ]; | |
| var vA = this.vertices[ face.a ]; | |
| var vB = this.vertices[ face.b ]; | |
| var vC = this.vertices[ face.c ]; | |
| cb.subVectors( vC, vB ); | |
| ab.subVectors( vA, vB ); | |
| cb.cross( ab ); | |
| cb.normalize(); | |
| face.normal.copy( cb ); | |
| } | |
| }, | |
| computeVertexNormals: function ( areaWeighted ) { | |
| if ( areaWeighted === undefined ) areaWeighted = true; | |
| var v, vl, f, fl, face, vertices; | |
| vertices = new Array( this.vertices.length ); | |
| for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) { | |
| vertices[ v ] = new THREE.Vector3(); | |
| } | |
| if ( areaWeighted ) { | |
| // vertex normals weighted by triangle areas | |
| // http://www.iquilezles.org/www/articles/normals/normals.htm | |
| var vA, vB, vC; | |
| var cb = new THREE.Vector3(), ab = new THREE.Vector3(); | |
| for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| face = this.faces[ f ]; | |
| vA = this.vertices[ face.a ]; | |
| vB = this.vertices[ face.b ]; | |
| vC = this.vertices[ face.c ]; | |
| cb.subVectors( vC, vB ); | |
| ab.subVectors( vA, vB ); | |
| cb.cross( ab ); | |
| vertices[ face.a ].add( cb ); | |
| vertices[ face.b ].add( cb ); | |
| vertices[ face.c ].add( cb ); | |
| } | |
| } else { | |
| for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| face = this.faces[ f ]; | |
| vertices[ face.a ].add( face.normal ); | |
| vertices[ face.b ].add( face.normal ); | |
| vertices[ face.c ].add( face.normal ); | |
| } | |
| } | |
| for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) { | |
| vertices[ v ].normalize(); | |
| } | |
| for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| face = this.faces[ f ]; | |
| var vertexNormals = face.vertexNormals; | |
| if ( vertexNormals.length === 3 ) { | |
| vertexNormals[ 0 ].copy( vertices[ face.a ] ); | |
| vertexNormals[ 1 ].copy( vertices[ face.b ] ); | |
| vertexNormals[ 2 ].copy( vertices[ face.c ] ); | |
| } else { | |
| vertexNormals[ 0 ] = vertices[ face.a ].clone(); | |
| vertexNormals[ 1 ] = vertices[ face.b ].clone(); | |
| vertexNormals[ 2 ] = vertices[ face.c ].clone(); | |
| } | |
| } | |
| if ( this.faces.length > 0 ) { | |
| this.normalsNeedUpdate = true; | |
| } | |
| }, | |
| computeMorphNormals: function () { | |
| var i, il, f, fl, face; | |
| // save original normals | |
| // - create temp variables on first access | |
| // otherwise just copy (for faster repeated calls) | |
| for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| face = this.faces[ f ]; | |
| if ( ! face.__originalFaceNormal ) { | |
| face.__originalFaceNormal = face.normal.clone(); | |
| } else { | |
| face.__originalFaceNormal.copy( face.normal ); | |
| } | |
| if ( ! face.__originalVertexNormals ) face.__originalVertexNormals = []; | |
| for ( i = 0, il = face.vertexNormals.length; i < il; i ++ ) { | |
| if ( ! face.__originalVertexNormals[ i ] ) { | |
| face.__originalVertexNormals[ i ] = face.vertexNormals[ i ].clone(); | |
| } else { | |
| face.__originalVertexNormals[ i ].copy( face.vertexNormals[ i ] ); | |
| } | |
| } | |
| } | |
| // use temp geometry to compute face and vertex normals for each morph | |
| var tmpGeo = new THREE.Geometry(); | |
| tmpGeo.faces = this.faces; | |
| for ( i = 0, il = this.morphTargets.length; i < il; i ++ ) { | |
| // create on first access | |
| if ( ! this.morphNormals[ i ] ) { | |
| this.morphNormals[ i ] = {}; | |
| this.morphNormals[ i ].faceNormals = []; | |
| this.morphNormals[ i ].vertexNormals = []; | |
| var dstNormalsFace = this.morphNormals[ i ].faceNormals; | |
| var dstNormalsVertex = this.morphNormals[ i ].vertexNormals; | |
| var faceNormal, vertexNormals; | |
| for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| faceNormal = new THREE.Vector3(); | |
| vertexNormals = { a: new THREE.Vector3(), b: new THREE.Vector3(), c: new THREE.Vector3() }; | |
| dstNormalsFace.push( faceNormal ); | |
| dstNormalsVertex.push( vertexNormals ); | |
| } | |
| } | |
| var morphNormals = this.morphNormals[ i ]; | |
| // set vertices to morph target | |
| tmpGeo.vertices = this.morphTargets[ i ].vertices; | |
| // compute morph normals | |
| tmpGeo.computeFaceNormals(); | |
| tmpGeo.computeVertexNormals(); | |
| // store morph normals | |
| var faceNormal, vertexNormals; | |
| for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| face = this.faces[ f ]; | |
| faceNormal = morphNormals.faceNormals[ f ]; | |
| vertexNormals = morphNormals.vertexNormals[ f ]; | |
| faceNormal.copy( face.normal ); | |
| vertexNormals.a.copy( face.vertexNormals[ 0 ] ); | |
| vertexNormals.b.copy( face.vertexNormals[ 1 ] ); | |
| vertexNormals.c.copy( face.vertexNormals[ 2 ] ); | |
| } | |
| } | |
| // restore original normals | |
| for ( f = 0, fl = this.faces.length; f < fl; f ++ ) { | |
| face = this.faces[ f ]; | |
| face.normal = face.__originalFaceNormal; | |
| face.vertexNormals = face.__originalVertexNormals; | |
| } | |
| }, | |
| computeTangents: function () { | |
| console.warn( 'THREE.Geometry: .computeTangents() has been removed.' ); | |
| }, | |
| computeLineDistances: function () { | |
| var d = 0; | |
| var vertices = this.vertices; | |
| for ( var i = 0, il = vertices.length; i < il; i ++ ) { | |
| if ( i > 0 ) { | |
| d += vertices[ i ].distanceTo( vertices[ i - 1 ] ); | |
| } | |
| this.lineDistances[ i ] = d; | |
| } | |
| }, | |
| computeBoundingBox: function () { | |
| if ( this.boundingBox === null ) { | |
| this.boundingBox = new THREE.Box3(); | |
| } | |
| this.boundingBox.setFromPoints( this.vertices ); | |
| }, | |
| computeBoundingSphere: function () { | |
| if ( this.boundingSphere === null ) { | |
| this.boundingSphere = new THREE.Sphere(); | |
| } | |
| this.boundingSphere.setFromPoints( this.vertices ); | |
| }, | |
| merge: function ( geometry, matrix, materialIndexOffset ) { | |
| if ( geometry instanceof THREE.Geometry === false ) { | |
| console.error( 'THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry ); | |
| return; | |
| } | |
| var normalMatrix, | |
| vertexOffset = this.vertices.length, | |
| vertices1 = this.vertices, | |
| vertices2 = geometry.vertices, | |
| faces1 = this.faces, | |
| faces2 = geometry.faces, | |
| uvs1 = this.faceVertexUvs[ 0 ], | |
| uvs2 = geometry.faceVertexUvs[ 0 ]; | |
| if ( materialIndexOffset === undefined ) materialIndexOffset = 0; | |
| if ( matrix !== undefined ) { | |
| normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix ); | |
| } | |
| // vertices | |
| for ( var i = 0, il = vertices2.length; i < il; i ++ ) { | |
| var vertex = vertices2[ i ]; | |
| var vertexCopy = vertex.clone(); | |
| if ( matrix !== undefined ) vertexCopy.applyMatrix4( matrix ); | |
| vertices1.push( vertexCopy ); | |
| } | |
| // faces | |
| for ( i = 0, il = faces2.length; i < il; i ++ ) { | |
| var face = faces2[ i ], faceCopy, normal, color, | |
| faceVertexNormals = face.vertexNormals, | |
| faceVertexColors = face.vertexColors; | |
| faceCopy = new THREE.Face3( face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset ); | |
| faceCopy.normal.copy( face.normal ); | |
| if ( normalMatrix !== undefined ) { | |
| faceCopy.normal.applyMatrix3( normalMatrix ).normalize(); | |
| } | |
| for ( var j = 0, jl = faceVertexNormals.length; j < jl; j ++ ) { | |
| normal = faceVertexNormals[ j ].clone(); | |
| if ( normalMatrix !== undefined ) { | |
| normal.applyMatrix3( normalMatrix ).normalize(); | |
| } | |
| faceCopy.vertexNormals.push( normal ); | |
| } | |
| faceCopy.color.copy( face.color ); | |
| for ( var j = 0, jl = faceVertexColors.length; j < jl; j ++ ) { | |
| color = faceVertexColors[ j ]; | |
| faceCopy.vertexColors.push( color.clone() ); | |
| } | |
| faceCopy.materialIndex = face.materialIndex + materialIndexOffset; | |
| faces1.push( faceCopy ); | |
| } | |
| // uvs | |
| for ( i = 0, il = uvs2.length; i < il; i ++ ) { | |
| var uv = uvs2[ i ], uvCopy = []; | |
| if ( uv === undefined ) { | |
| continue; | |
| } | |
| for ( var j = 0, jl = uv.length; j < jl; j ++ ) { | |
| uvCopy.push( uv[ j ].clone() ); | |
| } | |
| uvs1.push( uvCopy ); | |
| } | |
| }, | |
| mergeMesh: function ( mesh ) { | |
| if ( mesh instanceof THREE.Mesh === false ) { | |
| console.error( 'THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh ); | |
| return; | |
| } | |
| mesh.matrixAutoUpdate && mesh.updateMatrix(); | |
| this.merge( mesh.geometry, mesh.matrix ); | |
| }, | |
| /* | |
| * Checks for duplicate vertices with hashmap. | |
| * Duplicated vertices are removed | |
| * and faces' vertices are updated. | |
| */ | |
| mergeVertices: function () { | |
| var verticesMap = {}; // Hashmap for looking up vertices by position coordinates (and making sure they are unique) | |
| var unique = [], changes = []; | |
| var v, key; | |
| var precisionPoints = 4; // number of decimal points, e.g. 4 for epsilon of 0.0001 | |
| var precision = Math.pow( 10, precisionPoints ); | |
| var i, il, face; | |
| var indices, j, jl; | |
| for ( i = 0, il = this.vertices.length; i < il; i ++ ) { | |
| v = this.vertices[ i ]; | |
| key = Math.round( v.x * precision ) + '_' + Math.round( v.y * precision ) + '_' + Math.round( v.z * precision ); | |
| if ( verticesMap[ key ] === undefined ) { | |
| verticesMap[ key ] = i; | |
| unique.push( this.vertices[ i ] ); | |
| changes[ i ] = unique.length - 1; | |
| } else { | |
| //console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]); | |
| changes[ i ] = changes[ verticesMap[ key ] ]; | |
| } | |
| } | |
| // if faces are completely degenerate after merging vertices, we | |
| // have to remove them from the geometry. | |
| var faceIndicesToRemove = []; | |
| for ( i = 0, il = this.faces.length; i < il; i ++ ) { | |
| face = this.faces[ i ]; | |
| face.a = changes[ face.a ]; | |
| face.b = changes[ face.b ]; | |
| face.c = changes[ face.c ]; | |
| indices = [ face.a, face.b, face.c ]; | |
| var dupIndex = - 1; | |
| // if any duplicate vertices are found in a Face3 | |
| // we have to remove the face as nothing can be saved | |
| for ( var n = 0; n < 3; n ++ ) { | |
| if ( indices[ n ] === indices[ ( n + 1 ) % 3 ] ) { | |
| dupIndex = n; | |
| faceIndicesToRemove.push( i ); | |
| break; | |
| } | |
| } | |
| } | |
| for ( i = faceIndicesToRemove.length - 1; i >= 0; i -- ) { | |
| var idx = faceIndicesToRemove[ i ]; | |
| this.faces.splice( idx, 1 ); | |
| for ( j = 0, jl = this.faceVertexUvs.length; j < jl; j ++ ) { | |
| this.faceVertexUvs[ j ].splice( idx, 1 ); | |
| } | |
| } | |
| // Use unique set of vertices | |
| var diff = this.vertices.length - unique.length; | |
| this.vertices = unique; | |
| return diff; | |
| }, | |
| sortFacesByMaterialIndex: function () { | |
| var faces = this.faces; | |
| var length = faces.length; | |
| // tag faces | |
| for ( var i = 0; i < length; i ++ ) { | |
| faces[ i ]._id = i; | |
| } | |
| // sort faces | |
| function materialIndexSort( a, b ) { | |
| return a.materialIndex - b.materialIndex; | |
| } | |
| faces.sort( materialIndexSort ); | |
| // sort uvs | |
| var uvs1 = this.faceVertexUvs[ 0 ]; | |
| var uvs2 = this.faceVertexUvs[ 1 ]; | |
| var newUvs1, newUvs2; | |
| if ( uvs1 && uvs1.length === length ) newUvs1 = []; | |
| if ( uvs2 && uvs2.length === length ) newUvs2 = []; | |
| for ( var i = 0; i < length; i ++ ) { | |
| var id = faces[ i ]._id; | |
| if ( newUvs1 ) newUvs1.push( uvs1[ id ] ); | |
| if ( newUvs2 ) newUvs2.push( uvs2[ id ] ); | |
| } | |
| if ( newUvs1 ) this.faceVertexUvs[ 0 ] = newUvs1; | |
| if ( newUvs2 ) this.faceVertexUvs[ 1 ] = newUvs2; | |
| }, | |
| toJSON: function () { | |
| var data = { | |
| metadata: { | |
| version: 4.4, | |
| type: 'Geometry', | |
| generator: 'Geometry.toJSON' | |
| } | |
| }; | |
| // standard Geometry serialization | |
| data.uuid = this.uuid; | |
| data.type = this.type; | |
| if ( this.name !== '' ) data.name = this.name; | |
| if ( this.parameters !== undefined ) { | |
| var parameters = this.parameters; | |
| for ( var key in parameters ) { | |
| if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ]; | |
| } | |
| return data; | |
| } | |
| var vertices = []; | |
| for ( var i = 0; i < this.vertices.length; i ++ ) { | |
| var vertex = this.vertices[ i ]; | |
| vertices.push( vertex.x, vertex.y, vertex.z ); | |
| } | |
| var faces = []; | |
| var normals = []; | |
| var normalsHash = {}; | |
| var colors = []; | |
| var colorsHash = {}; | |
| var uvs = []; | |
| var uvsHash = {}; | |
| for ( var i = 0; i < this.faces.length; i ++ ) { | |
| var face = this.faces[ i ]; | |
| var hasMaterial = true; | |
| var hasFaceUv = false; // deprecated | |
| var hasFaceVertexUv = this.faceVertexUvs[ 0 ][ i ] !== undefined; | |
| var hasFaceNormal = face.normal.length() > 0; | |
| var hasFaceVertexNormal = face.vertexNormals.length > 0; | |
| var hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1; | |
| var hasFaceVertexColor = face.vertexColors.length > 0; | |
| var faceType = 0; | |
| faceType = setBit( faceType, 0, 0 ); // isQuad | |
| faceType = setBit( faceType, 1, hasMaterial ); | |
| faceType = setBit( faceType, 2, hasFaceUv ); | |
| faceType = setBit( faceType, 3, hasFaceVertexUv ); | |
| faceType = setBit( faceType, 4, hasFaceNormal ); | |
| faceType = setBit( faceType, 5, hasFaceVertexNormal ); | |
| faceType = setBit( faceType, 6, hasFaceColor ); | |
| faceType = setBit( faceType, 7, hasFaceVertexColor ); | |
| faces.push( faceType ); | |
| faces.push( face.a, face.b, face.c ); | |
| faces.push( face.materialIndex ); | |
| if ( hasFaceVertexUv ) { | |
| var faceVertexUvs = this.faceVertexUvs[ 0 ][ i ]; | |
| faces.push( | |
| getUvIndex( faceVertexUvs[ 0 ] ), | |
| getUvIndex( faceVertexUvs[ 1 ] ), | |
| getUvIndex( faceVertexUvs[ 2 ] ) | |
| ); | |
| } | |
| if ( hasFaceNormal ) { | |
| faces.push( getNormalIndex( face.normal ) ); | |
| } | |
| if ( hasFaceVertexNormal ) { | |
| var vertexNormals = face.vertexNormals; | |
| faces.push( | |
| getNormalIndex( vertexNormals[ 0 ] ), | |
| getNormalIndex( vertexNormals[ 1 ] ), | |
| getNormalIndex( vertexNormals[ 2 ] ) | |
| ); | |
| } | |
| if ( hasFaceColor ) { | |
| faces.push( getColorIndex( face.color ) ); | |
| } | |
| if ( hasFaceVertexColor ) { | |
| var vertexColors = face.vertexColors; | |
| faces.push( | |
| getColorIndex( vertexColors[ 0 ] ), | |
| getColorIndex( vertexColors[ 1 ] ), | |
| getColorIndex( vertexColors[ 2 ] ) | |
| ); | |
| } | |
| } | |
| function setBit( value, position, enabled ) { | |
| return enabled ? value | ( 1 << position ) : value & ( ~ ( 1 << position ) ); | |
| } | |
| function getNormalIndex( normal ) { | |
| var hash = normal.x.toString() + normal.y.toString() + normal.z.toString(); | |
| if ( normalsHash[ hash ] !== undefined ) { | |
| return normalsHash[ hash ]; | |
| } | |
| normalsHash[ hash ] = normals.length / 3; | |
| normals.push( normal.x, normal.y, normal.z ); | |
| return normalsHash[ hash ]; | |
| } | |
| function getColorIndex( color ) { | |
| var hash = color.r.toString() + color.g.toString() + color.b.toString(); | |
| if ( colorsHash[ hash ] !== undefined ) { | |
| return colorsHash[ hash ]; | |
| } | |
| colorsHash[ hash ] = colors.length; | |
| colors.push( color.getHex() ); | |
| return colorsHash[ hash ]; | |
| } | |
| function getUvIndex( uv ) { | |
| var hash = uv.x.toString() + uv.y.toString(); | |
| if ( uvsHash[ hash ] !== undefined ) { | |
| return uvsHash[ hash ]; | |
| } | |
| uvsHash[ hash ] = uvs.length / 2; | |
| uvs.push( uv.x, uv.y ); | |
| return uvsHash[ hash ]; | |
| } | |
| data.data = {}; | |
| data.data.vertices = vertices; | |
| data.data.normals = normals; | |
| if ( colors.length > 0 ) data.data.colors = colors; | |
| if ( uvs.length > 0 ) data.data.uvs = [ uvs ]; // temporal backward compatibility | |
| data.data.faces = faces; | |
| return data; | |
| }, | |
| clone: function () { | |
| /* | |
| // Handle primitives | |
| var parameters = this.parameters; | |
| if ( parameters !== undefined ) { | |
| var values = []; | |
| for ( var key in parameters ) { | |
| values.push( parameters[ key ] ); | |
| } | |
| var geometry = Object.create( this.constructor.prototype ); | |
| this.constructor.apply( geometry, values ); | |
| return geometry; | |
| } | |
| return new this.constructor().copy( this ); | |
| */ | |
| return new THREE.Geometry().copy( this ); | |
| }, | |
| copy: function ( source ) { | |
| this.vertices = []; | |
| this.faces = []; | |
| this.faceVertexUvs = [ [] ]; | |
| var vertices = source.vertices; | |
| for ( var i = 0, il = vertices.length; i < il; i ++ ) { | |
| this.vertices.push( vertices[ i ].clone() ); | |
| } | |
| var faces = source.faces; | |
| for ( var i = 0, il = faces.length; i < il; i ++ ) { | |
| this.faces.push( faces[ i ].clone() ); | |
| } | |
| for ( var i = 0, il = source.faceVertexUvs.length; i < il; i ++ ) { | |
| var faceVertexUvs = source.faceVertexUvs[ i ]; | |
| if ( this.faceVertexUvs[ i ] === undefined ) { | |
| this.faceVertexUvs[ i ] = []; | |
| } | |
| for ( var j = 0, jl = faceVertexUvs.length; j < jl; j ++ ) { | |
| var uvs = faceVertexUvs[ j ], uvsCopy = []; | |
| for ( var k = 0, kl = uvs.length; k < kl; k ++ ) { | |
| var uv = uvs[ k ]; | |
| uvsCopy.push( uv.clone() ); | |
| } | |
| this.faceVertexUvs[ i ].push( uvsCopy ); | |
| } | |
| } | |
| return this; | |
| }, | |
| dispose: function () { | |
| this.dispatchEvent( { type: 'dispose' } ); | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.Geometry.prototype ); | |
| THREE.GeometryIdCount = 0; | |
| // File:src/core/DirectGeometry.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.DirectGeometry = function () { | |
| Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } ); | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.name = ''; | |
| this.type = 'DirectGeometry'; | |
| this.indices = []; | |
| this.vertices = []; | |
| this.normals = []; | |
| this.colors = []; | |
| this.uvs = []; | |
| this.uvs2 = []; | |
| this.groups = []; | |
| this.morphTargets = {}; | |
| this.skinWeights = []; | |
| this.skinIndices = []; | |
| // this.lineDistances = []; | |
| this.boundingBox = null; | |
| this.boundingSphere = null; | |
| // update flags | |
| this.verticesNeedUpdate = false; | |
| this.normalsNeedUpdate = false; | |
| this.colorsNeedUpdate = false; | |
| this.uvsNeedUpdate = false; | |
| this.groupsNeedUpdate = false; | |
| }; | |
| THREE.DirectGeometry.prototype = { | |
| constructor: THREE.DirectGeometry, | |
| computeBoundingBox: THREE.Geometry.prototype.computeBoundingBox, | |
| computeBoundingSphere: THREE.Geometry.prototype.computeBoundingSphere, | |
| computeFaceNormals: function () { | |
| console.warn( 'THREE.DirectGeometry: computeFaceNormals() is not a method of this type of geometry.' ); | |
| }, | |
| computeVertexNormals: function () { | |
| console.warn( 'THREE.DirectGeometry: computeVertexNormals() is not a method of this type of geometry.' ); | |
| }, | |
| computeGroups: function ( geometry ) { | |
| var group; | |
| var groups = []; | |
| var materialIndex; | |
| var faces = geometry.faces; | |
| for ( var i = 0; i < faces.length; i ++ ) { | |
| var face = faces[ i ]; | |
| // materials | |
| if ( face.materialIndex !== materialIndex ) { | |
| materialIndex = face.materialIndex; | |
| if ( group !== undefined ) { | |
| group.count = ( i * 3 ) - group.start; | |
| groups.push( group ); | |
| } | |
| group = { | |
| start: i * 3, | |
| materialIndex: materialIndex | |
| }; | |
| } | |
| } | |
| if ( group !== undefined ) { | |
| group.count = ( i * 3 ) - group.start; | |
| groups.push( group ); | |
| } | |
| this.groups = groups; | |
| }, | |
| fromGeometry: function ( geometry ) { | |
| var faces = geometry.faces; | |
| var vertices = geometry.vertices; | |
| var faceVertexUvs = geometry.faceVertexUvs; | |
| var hasFaceVertexUv = faceVertexUvs[ 0 ] && faceVertexUvs[ 0 ].length > 0; | |
| var hasFaceVertexUv2 = faceVertexUvs[ 1 ] && faceVertexUvs[ 1 ].length > 0; | |
| // morphs | |
| var morphTargets = geometry.morphTargets; | |
| var morphTargetsLength = morphTargets.length; | |
| var morphTargetsPosition; | |
| if ( morphTargetsLength > 0 ) { | |
| morphTargetsPosition = []; | |
| for ( var i = 0; i < morphTargetsLength; i ++ ) { | |
| morphTargetsPosition[ i ] = []; | |
| } | |
| this.morphTargets.position = morphTargetsPosition; | |
| } | |
| var morphNormals = geometry.morphNormals; | |
| var morphNormalsLength = morphNormals.length; | |
| var morphTargetsNormal; | |
| if ( morphNormalsLength > 0 ) { | |
| morphTargetsNormal = []; | |
| for ( var i = 0; i < morphNormalsLength; i ++ ) { | |
| morphTargetsNormal[ i ] = []; | |
| } | |
| this.morphTargets.normal = morphTargetsNormal; | |
| } | |
| // skins | |
| var skinIndices = geometry.skinIndices; | |
| var skinWeights = geometry.skinWeights; | |
| var hasSkinIndices = skinIndices.length === vertices.length; | |
| var hasSkinWeights = skinWeights.length === vertices.length; | |
| // | |
| for ( var i = 0; i < faces.length; i ++ ) { | |
| var face = faces[ i ]; | |
| this.vertices.push( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ] ); | |
| var vertexNormals = face.vertexNormals; | |
| if ( vertexNormals.length === 3 ) { | |
| this.normals.push( vertexNormals[ 0 ], vertexNormals[ 1 ], vertexNormals[ 2 ] ); | |
| } else { | |
| var normal = face.normal; | |
| this.normals.push( normal, normal, normal ); | |
| } | |
| var vertexColors = face.vertexColors; | |
| if ( vertexColors.length === 3 ) { | |
| this.colors.push( vertexColors[ 0 ], vertexColors[ 1 ], vertexColors[ 2 ] ); | |
| } else { | |
| var color = face.color; | |
| this.colors.push( color, color, color ); | |
| } | |
| if ( hasFaceVertexUv === true ) { | |
| var vertexUvs = faceVertexUvs[ 0 ][ i ]; | |
| if ( vertexUvs !== undefined ) { | |
| this.uvs.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] ); | |
| } else { | |
| console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', i ); | |
| this.uvs.push( new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() ); | |
| } | |
| } | |
| if ( hasFaceVertexUv2 === true ) { | |
| var vertexUvs = faceVertexUvs[ 1 ][ i ]; | |
| if ( vertexUvs !== undefined ) { | |
| this.uvs2.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] ); | |
| } else { | |
| console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i ); | |
| this.uvs2.push( new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() ); | |
| } | |
| } | |
| // morphs | |
| for ( var j = 0; j < morphTargetsLength; j ++ ) { | |
| var morphTarget = morphTargets[ j ].vertices; | |
| morphTargetsPosition[ j ].push( morphTarget[ face.a ], morphTarget[ face.b ], morphTarget[ face.c ] ); | |
| } | |
| for ( var j = 0; j < morphNormalsLength; j ++ ) { | |
| var morphNormal = morphNormals[ j ].vertexNormals[ i ]; | |
| morphTargetsNormal[ j ].push( morphNormal.a, morphNormal.b, morphNormal.c ); | |
| } | |
| // skins | |
| if ( hasSkinIndices ) { | |
| this.skinIndices.push( skinIndices[ face.a ], skinIndices[ face.b ], skinIndices[ face.c ] ); | |
| } | |
| if ( hasSkinWeights ) { | |
| this.skinWeights.push( skinWeights[ face.a ], skinWeights[ face.b ], skinWeights[ face.c ] ); | |
| } | |
| } | |
| this.computeGroups( geometry ); | |
| this.verticesNeedUpdate = geometry.verticesNeedUpdate; | |
| this.normalsNeedUpdate = geometry.normalsNeedUpdate; | |
| this.colorsNeedUpdate = geometry.colorsNeedUpdate; | |
| this.uvsNeedUpdate = geometry.uvsNeedUpdate; | |
| this.groupsNeedUpdate = geometry.groupsNeedUpdate; | |
| return this; | |
| }, | |
| dispose: function () { | |
| this.dispatchEvent( { type: 'dispose' } ); | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.DirectGeometry.prototype ); | |
| // File:src/core/BufferGeometry.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.BufferGeometry = function () { | |
| Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } ); | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.name = ''; | |
| this.type = 'BufferGeometry'; | |
| this.index = null; | |
| this.attributes = {}; | |
| this.morphAttributes = {}; | |
| this.groups = []; | |
| this.boundingBox = null; | |
| this.boundingSphere = null; | |
| this.drawRange = { start: 0, count: Infinity }; | |
| }; | |
| THREE.BufferGeometry.prototype = { | |
| constructor: THREE.BufferGeometry, | |
| getIndex: function () { | |
| return this.index; | |
| }, | |
| setIndex: function ( index ) { | |
| this.index = index; | |
| }, | |
| addAttribute: function ( name, attribute ) { | |
| if ( attribute instanceof THREE.BufferAttribute === false && attribute instanceof THREE.InterleavedBufferAttribute === false ) { | |
| console.warn( 'THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).' ); | |
| this.addAttribute( name, new THREE.BufferAttribute( arguments[ 1 ], arguments[ 2 ] ) ); | |
| return; | |
| } | |
| if ( name === 'index' ) { | |
| console.warn( 'THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.' ); | |
| this.setIndex( attribute ); | |
| return; | |
| } | |
| this.attributes[ name ] = attribute; | |
| return this; | |
| }, | |
| getAttribute: function ( name ) { | |
| return this.attributes[ name ]; | |
| }, | |
| removeAttribute: function ( name ) { | |
| delete this.attributes[ name ]; | |
| return this; | |
| }, | |
| addGroup: function ( start, count, materialIndex ) { | |
| this.groups.push( { | |
| start: start, | |
| count: count, | |
| materialIndex: materialIndex !== undefined ? materialIndex : 0 | |
| } ); | |
| }, | |
| clearGroups: function () { | |
| this.groups = []; | |
| }, | |
| setDrawRange: function ( start, count ) { | |
| this.drawRange.start = start; | |
| this.drawRange.count = count; | |
| }, | |
| applyMatrix: function ( matrix ) { | |
| var position = this.attributes.position; | |
| if ( position !== undefined ) { | |
| matrix.applyToVector3Array( position.array ); | |
| position.needsUpdate = true; | |
| } | |
| var normal = this.attributes.normal; | |
| if ( normal !== undefined ) { | |
| var normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix ); | |
| normalMatrix.applyToVector3Array( normal.array ); | |
| normal.needsUpdate = true; | |
| } | |
| if ( this.boundingBox !== null ) { | |
| this.computeBoundingBox(); | |
| } | |
| if ( this.boundingSphere !== null ) { | |
| this.computeBoundingSphere(); | |
| } | |
| }, | |
| rotateX: function () { | |
| // rotate geometry around world x-axis | |
| var m1; | |
| return function rotateX( angle ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeRotationX( angle ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| rotateY: function () { | |
| // rotate geometry around world y-axis | |
| var m1; | |
| return function rotateY( angle ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeRotationY( angle ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| rotateZ: function () { | |
| // rotate geometry around world z-axis | |
| var m1; | |
| return function rotateZ( angle ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeRotationZ( angle ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| translate: function () { | |
| // translate geometry | |
| var m1; | |
| return function translate( x, y, z ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeTranslation( x, y, z ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| scale: function () { | |
| // scale geometry | |
| var m1; | |
| return function scale( x, y, z ) { | |
| if ( m1 === undefined ) m1 = new THREE.Matrix4(); | |
| m1.makeScale( x, y, z ); | |
| this.applyMatrix( m1 ); | |
| return this; | |
| }; | |
| }(), | |
| lookAt: function () { | |
| var obj; | |
| return function lookAt( vector ) { | |
| if ( obj === undefined ) obj = new THREE.Object3D(); | |
| obj.lookAt( vector ); | |
| obj.updateMatrix(); | |
| this.applyMatrix( obj.matrix ); | |
| }; | |
| }(), | |
| center: function () { | |
| this.computeBoundingBox(); | |
| var offset = this.boundingBox.center().negate(); | |
| this.translate( offset.x, offset.y, offset.z ); | |
| return offset; | |
| }, | |
| setFromObject: function ( object ) { | |
| // console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this ); | |
| var geometry = object.geometry; | |
| if ( object instanceof THREE.Points || object instanceof THREE.Line ) { | |
| var positions = new THREE.Float32Attribute( geometry.vertices.length * 3, 3 ); | |
| var colors = new THREE.Float32Attribute( geometry.colors.length * 3, 3 ); | |
| this.addAttribute( 'position', positions.copyVector3sArray( geometry.vertices ) ); | |
| this.addAttribute( 'color', colors.copyColorsArray( geometry.colors ) ); | |
| if ( geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length ) { | |
| var lineDistances = new THREE.Float32Attribute( geometry.lineDistances.length, 1 ); | |
| this.addAttribute( 'lineDistance', lineDistances.copyArray( geometry.lineDistances ) ); | |
| } | |
| if ( geometry.boundingSphere !== null ) { | |
| this.boundingSphere = geometry.boundingSphere.clone(); | |
| } | |
| if ( geometry.boundingBox !== null ) { | |
| this.boundingBox = geometry.boundingBox.clone(); | |
| } | |
| } else if ( object instanceof THREE.Mesh ) { | |
| if ( geometry instanceof THREE.Geometry ) { | |
| this.fromGeometry( geometry ); | |
| } | |
| } | |
| return this; | |
| }, | |
| updateFromObject: function ( object ) { | |
| var geometry = object.geometry; | |
| if ( object instanceof THREE.Mesh ) { | |
| var direct = geometry.__directGeometry; | |
| if ( direct === undefined ) { | |
| return this.fromGeometry( geometry ); | |
| } | |
| direct.verticesNeedUpdate = geometry.verticesNeedUpdate; | |
| direct.normalsNeedUpdate = geometry.normalsNeedUpdate; | |
| direct.colorsNeedUpdate = geometry.colorsNeedUpdate; | |
| direct.uvsNeedUpdate = geometry.uvsNeedUpdate; | |
| direct.groupsNeedUpdate = geometry.groupsNeedUpdate; | |
| geometry.verticesNeedUpdate = false; | |
| geometry.normalsNeedUpdate = false; | |
| geometry.colorsNeedUpdate = false; | |
| geometry.uvsNeedUpdate = false; | |
| geometry.groupsNeedUpdate = false; | |
| geometry = direct; | |
| } | |
| if ( geometry.verticesNeedUpdate === true ) { | |
| var attribute = this.attributes.position; | |
| if ( attribute !== undefined ) { | |
| attribute.copyVector3sArray( geometry.vertices ); | |
| attribute.needsUpdate = true; | |
| } | |
| geometry.verticesNeedUpdate = false; | |
| } | |
| if ( geometry.normalsNeedUpdate === true ) { | |
| var attribute = this.attributes.normal; | |
| if ( attribute !== undefined ) { | |
| attribute.copyVector3sArray( geometry.normals ); | |
| attribute.needsUpdate = true; | |
| } | |
| geometry.normalsNeedUpdate = false; | |
| } | |
| if ( geometry.colorsNeedUpdate === true ) { | |
| var attribute = this.attributes.color; | |
| if ( attribute !== undefined ) { | |
| attribute.copyColorsArray( geometry.colors ); | |
| attribute.needsUpdate = true; | |
| } | |
| geometry.colorsNeedUpdate = false; | |
| } | |
| if ( geometry.uvsNeedUpdate ) { | |
| var attribute = this.attributes.uv; | |
| if ( attribute !== undefined ) { | |
| attribute.copyVector2sArray( geometry.uvs ); | |
| attribute.needsUpdate = true; | |
| } | |
| geometry.uvsNeedUpdate = false; | |
| } | |
| if ( geometry.lineDistancesNeedUpdate ) { | |
| var attribute = this.attributes.lineDistance; | |
| if ( attribute !== undefined ) { | |
| attribute.copyArray( geometry.lineDistances ); | |
| attribute.needsUpdate = true; | |
| } | |
| geometry.lineDistancesNeedUpdate = false; | |
| } | |
| if ( geometry.groupsNeedUpdate ) { | |
| geometry.computeGroups( object.geometry ); | |
| this.groups = geometry.groups; | |
| geometry.groupsNeedUpdate = false; | |
| } | |
| return this; | |
| }, | |
| fromGeometry: function ( geometry ) { | |
| geometry.__directGeometry = new THREE.DirectGeometry().fromGeometry( geometry ); | |
| return this.fromDirectGeometry( geometry.__directGeometry ); | |
| }, | |
| fromDirectGeometry: function ( geometry ) { | |
| var positions = new Float32Array( geometry.vertices.length * 3 ); | |
| this.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ).copyVector3sArray( geometry.vertices ) ); | |
| if ( geometry.normals.length > 0 ) { | |
| var normals = new Float32Array( geometry.normals.length * 3 ); | |
| this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ).copyVector3sArray( geometry.normals ) ); | |
| } | |
| if ( geometry.colors.length > 0 ) { | |
| var colors = new Float32Array( geometry.colors.length * 3 ); | |
| this.addAttribute( 'color', new THREE.BufferAttribute( colors, 3 ).copyColorsArray( geometry.colors ) ); | |
| } | |
| if ( geometry.uvs.length > 0 ) { | |
| var uvs = new Float32Array( geometry.uvs.length * 2 ); | |
| this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ).copyVector2sArray( geometry.uvs ) ); | |
| } | |
| if ( geometry.uvs2.length > 0 ) { | |
| var uvs2 = new Float32Array( geometry.uvs2.length * 2 ); | |
| this.addAttribute( 'uv2', new THREE.BufferAttribute( uvs2, 2 ).copyVector2sArray( geometry.uvs2 ) ); | |
| } | |
| if ( geometry.indices.length > 0 ) { | |
| var TypeArray = geometry.vertices.length > 65535 ? Uint32Array : Uint16Array; | |
| var indices = new TypeArray( geometry.indices.length * 3 ); | |
| this.setIndex( new THREE.BufferAttribute( indices, 1 ).copyIndicesArray( geometry.indices ) ); | |
| } | |
| // groups | |
| this.groups = geometry.groups; | |
| // morphs | |
| for ( var name in geometry.morphTargets ) { | |
| var array = []; | |
| var morphTargets = geometry.morphTargets[ name ]; | |
| for ( var i = 0, l = morphTargets.length; i < l; i ++ ) { | |
| var morphTarget = morphTargets[ i ]; | |
| var attribute = new THREE.Float32Attribute( morphTarget.length * 3, 3 ); | |
| array.push( attribute.copyVector3sArray( morphTarget ) ); | |
| } | |
| this.morphAttributes[ name ] = array; | |
| } | |
| // skinning | |
| if ( geometry.skinIndices.length > 0 ) { | |
| var skinIndices = new THREE.Float32Attribute( geometry.skinIndices.length * 4, 4 ); | |
| this.addAttribute( 'skinIndex', skinIndices.copyVector4sArray( geometry.skinIndices ) ); | |
| } | |
| if ( geometry.skinWeights.length > 0 ) { | |
| var skinWeights = new THREE.Float32Attribute( geometry.skinWeights.length * 4, 4 ); | |
| this.addAttribute( 'skinWeight', skinWeights.copyVector4sArray( geometry.skinWeights ) ); | |
| } | |
| // | |
| if ( geometry.boundingSphere !== null ) { | |
| this.boundingSphere = geometry.boundingSphere.clone(); | |
| } | |
| if ( geometry.boundingBox !== null ) { | |
| this.boundingBox = geometry.boundingBox.clone(); | |
| } | |
| return this; | |
| }, | |
| computeBoundingBox: function () { | |
| var vector = new THREE.Vector3(); | |
| return function () { | |
| if ( this.boundingBox === null ) { | |
| this.boundingBox = new THREE.Box3(); | |
| } | |
| var positions = this.attributes.position.array; | |
| if ( positions ) { | |
| this.boundingBox.setFromArray( positions ); | |
| } | |
| if ( positions === undefined || positions.length === 0 ) { | |
| this.boundingBox.min.set( 0, 0, 0 ); | |
| this.boundingBox.max.set( 0, 0, 0 ); | |
| } | |
| if ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) { | |
| console.error( 'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this ); | |
| } | |
| }; | |
| }(), | |
| computeBoundingSphere: function () { | |
| var box = new THREE.Box3(); | |
| var vector = new THREE.Vector3(); | |
| return function () { | |
| if ( this.boundingSphere === null ) { | |
| this.boundingSphere = new THREE.Sphere(); | |
| } | |
| var positions = this.attributes.position.array; | |
| if ( positions ) { | |
| var center = this.boundingSphere.center; | |
| box.setFromArray( positions ); | |
| box.center( center ); | |
| // hoping to find a boundingSphere with a radius smaller than the | |
| // boundingSphere of the boundingBox: sqrt(3) smaller in the best case | |
| var maxRadiusSq = 0; | |
| for ( var i = 0, il = positions.length; i < il; i += 3 ) { | |
| vector.fromArray( positions, i ); | |
| maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) ); | |
| } | |
| this.boundingSphere.radius = Math.sqrt( maxRadiusSq ); | |
| if ( isNaN( this.boundingSphere.radius ) ) { | |
| console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this ); | |
| } | |
| } | |
| }; | |
| }(), | |
| computeFaceNormals: function () { | |
| // backwards compatibility | |
| }, | |
| computeVertexNormals: function () { | |
| var index = this.index; | |
| var attributes = this.attributes; | |
| var groups = this.groups; | |
| if ( attributes.position ) { | |
| var positions = attributes.position.array; | |
| if ( attributes.normal === undefined ) { | |
| this.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( positions.length ), 3 ) ); | |
| } else { | |
| // reset existing normals to zero | |
| var array = attributes.normal.array; | |
| for ( var i = 0, il = array.length; i < il; i ++ ) { | |
| array[ i ] = 0; | |
| } | |
| } | |
| var normals = attributes.normal.array; | |
| var vA, vB, vC, | |
| pA = new THREE.Vector3(), | |
| pB = new THREE.Vector3(), | |
| pC = new THREE.Vector3(), | |
| cb = new THREE.Vector3(), | |
| ab = new THREE.Vector3(); | |
| // indexed elements | |
| if ( index ) { | |
| var indices = index.array; | |
| if ( groups.length === 0 ) { | |
| this.addGroup( 0, indices.length ); | |
| } | |
| for ( var j = 0, jl = groups.length; j < jl; ++ j ) { | |
| var group = groups[ j ]; | |
| var start = group.start; | |
| var count = group.count; | |
| for ( var i = start, il = start + count; i < il; i += 3 ) { | |
| vA = indices[ i + 0 ] * 3; | |
| vB = indices[ i + 1 ] * 3; | |
| vC = indices[ i + 2 ] * 3; | |
| pA.fromArray( positions, vA ); | |
| pB.fromArray( positions, vB ); | |
| pC.fromArray( positions, vC ); | |
| cb.subVectors( pC, pB ); | |
| ab.subVectors( pA, pB ); | |
| cb.cross( ab ); | |
| normals[ vA ] += cb.x; | |
| normals[ vA + 1 ] += cb.y; | |
| normals[ vA + 2 ] += cb.z; | |
| normals[ vB ] += cb.x; | |
| normals[ vB + 1 ] += cb.y; | |
| normals[ vB + 2 ] += cb.z; | |
| normals[ vC ] += cb.x; | |
| normals[ vC + 1 ] += cb.y; | |
| normals[ vC + 2 ] += cb.z; | |
| } | |
| } | |
| } else { | |
| // non-indexed elements (unconnected triangle soup) | |
| for ( var i = 0, il = positions.length; i < il; i += 9 ) { | |
| pA.fromArray( positions, i ); | |
| pB.fromArray( positions, i + 3 ); | |
| pC.fromArray( positions, i + 6 ); | |
| cb.subVectors( pC, pB ); | |
| ab.subVectors( pA, pB ); | |
| cb.cross( ab ); | |
| normals[ i ] = cb.x; | |
| normals[ i + 1 ] = cb.y; | |
| normals[ i + 2 ] = cb.z; | |
| normals[ i + 3 ] = cb.x; | |
| normals[ i + 4 ] = cb.y; | |
| normals[ i + 5 ] = cb.z; | |
| normals[ i + 6 ] = cb.x; | |
| normals[ i + 7 ] = cb.y; | |
| normals[ i + 8 ] = cb.z; | |
| } | |
| } | |
| this.normalizeNormals(); | |
| attributes.normal.needsUpdate = true; | |
| } | |
| }, | |
| merge: function ( geometry, offset ) { | |
| if ( geometry instanceof THREE.BufferGeometry === false ) { | |
| console.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry ); | |
| return; | |
| } | |
| if ( offset === undefined ) offset = 0; | |
| var attributes = this.attributes; | |
| for ( var key in attributes ) { | |
| if ( geometry.attributes[ key ] === undefined ) continue; | |
| var attribute1 = attributes[ key ]; | |
| var attributeArray1 = attribute1.array; | |
| var attribute2 = geometry.attributes[ key ]; | |
| var attributeArray2 = attribute2.array; | |
| var attributeSize = attribute2.itemSize; | |
| for ( var i = 0, j = attributeSize * offset; i < attributeArray2.length; i ++, j ++ ) { | |
| attributeArray1[ j ] = attributeArray2[ i ]; | |
| } | |
| } | |
| return this; | |
| }, | |
| normalizeNormals: function () { | |
| var normals = this.attributes.normal.array; | |
| var x, y, z, n; | |
| for ( var i = 0, il = normals.length; i < il; i += 3 ) { | |
| x = normals[ i ]; | |
| y = normals[ i + 1 ]; | |
| z = normals[ i + 2 ]; | |
| n = 1.0 / Math.sqrt( x * x + y * y + z * z ); | |
| normals[ i ] *= n; | |
| normals[ i + 1 ] *= n; | |
| normals[ i + 2 ] *= n; | |
| } | |
| }, | |
| toNonIndexed: function () { | |
| if ( this.index === null ) { | |
| console.warn( 'THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.' ); | |
| return this; | |
| } | |
| var geometry2 = new THREE.BufferGeometry(); | |
| var indices = this.index.array; | |
| var attributes = this.attributes; | |
| for ( var name in attributes ) { | |
| var attribute = attributes[ name ]; | |
| var array = attribute.array; | |
| var itemSize = attribute.itemSize; | |
| var array2 = new array.constructor( indices.length * itemSize ); | |
| var index = 0, index2 = 0; | |
| for ( var i = 0, l = indices.length; i < l; i ++ ) { | |
| index = indices[ i ] * itemSize; | |
| for ( var j = 0; j < itemSize; j ++ ) { | |
| array2[ index2 ++ ] = array[ index ++ ]; | |
| } | |
| } | |
| geometry2.addAttribute( name, new THREE.BufferAttribute( array2, itemSize ) ); | |
| } | |
| return geometry2; | |
| }, | |
| toJSON: function () { | |
| var data = { | |
| metadata: { | |
| version: 4.4, | |
| type: 'BufferGeometry', | |
| generator: 'BufferGeometry.toJSON' | |
| } | |
| }; | |
| // standard BufferGeometry serialization | |
| data.uuid = this.uuid; | |
| data.type = this.type; | |
| if ( this.name !== '' ) data.name = this.name; | |
| if ( this.parameters !== undefined ) { | |
| var parameters = this.parameters; | |
| for ( var key in parameters ) { | |
| if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ]; | |
| } | |
| return data; | |
| } | |
| data.data = { attributes: {} }; | |
| var index = this.index; | |
| if ( index !== null ) { | |
| var array = Array.prototype.slice.call( index.array ); | |
| data.data.index = { | |
| type: index.array.constructor.name, | |
| array: array | |
| }; | |
| } | |
| var attributes = this.attributes; | |
| for ( var key in attributes ) { | |
| var attribute = attributes[ key ]; | |
| var array = Array.prototype.slice.call( attribute.array ); | |
| data.data.attributes[ key ] = { | |
| itemSize: attribute.itemSize, | |
| type: attribute.array.constructor.name, | |
| array: array | |
| }; | |
| } | |
| var groups = this.groups; | |
| if ( groups.length > 0 ) { | |
| data.data.groups = JSON.parse( JSON.stringify( groups ) ); | |
| } | |
| var boundingSphere = this.boundingSphere; | |
| if ( boundingSphere !== null ) { | |
| data.data.boundingSphere = { | |
| center: boundingSphere.center.toArray(), | |
| radius: boundingSphere.radius | |
| }; | |
| } | |
| return data; | |
| }, | |
| clone: function () { | |
| /* | |
| // Handle primitives | |
| var parameters = this.parameters; | |
| if ( parameters !== undefined ) { | |
| var values = []; | |
| for ( var key in parameters ) { | |
| values.push( parameters[ key ] ); | |
| } | |
| var geometry = Object.create( this.constructor.prototype ); | |
| this.constructor.apply( geometry, values ); | |
| return geometry; | |
| } | |
| return new this.constructor().copy( this ); | |
| */ | |
| return new THREE.BufferGeometry().copy( this ); | |
| }, | |
| copy: function ( source ) { | |
| var index = source.index; | |
| if ( index !== null ) { | |
| this.setIndex( index.clone() ); | |
| } | |
| var attributes = source.attributes; | |
| for ( var name in attributes ) { | |
| var attribute = attributes[ name ]; | |
| this.addAttribute( name, attribute.clone() ); | |
| } | |
| var groups = source.groups; | |
| for ( var i = 0, l = groups.length; i < l; i ++ ) { | |
| var group = groups[ i ]; | |
| this.addGroup( group.start, group.count ); | |
| } | |
| return this; | |
| }, | |
| dispose: function () { | |
| this.dispatchEvent( { type: 'dispose' } ); | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.BufferGeometry.prototype ); | |
| THREE.BufferGeometry.MaxIndex = 65535; | |
| // File:src/core/InstancedBufferGeometry.js | |
| /** | |
| * @author benaadams / https://twitter.com/ben_a_adams | |
| */ | |
| THREE.InstancedBufferGeometry = function () { | |
| THREE.BufferGeometry.call( this ); | |
| this.type = 'InstancedBufferGeometry'; | |
| this.maxInstancedCount = undefined; | |
| }; | |
| THREE.InstancedBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype ); | |
| THREE.InstancedBufferGeometry.prototype.constructor = THREE.InstancedBufferGeometry; | |
| THREE.InstancedBufferGeometry.prototype.addGroup = function ( start, count, instances ) { | |
| this.groups.push( { | |
| start: start, | |
| count: count, | |
| instances: instances | |
| } ); | |
| }; | |
| THREE.InstancedBufferGeometry.prototype.copy = function ( source ) { | |
| var index = source.index; | |
| if ( index !== null ) { | |
| this.setIndex( index.clone() ); | |
| } | |
| var attributes = source.attributes; | |
| for ( var name in attributes ) { | |
| var attribute = attributes[ name ]; | |
| this.addAttribute( name, attribute.clone() ); | |
| } | |
| var groups = source.groups; | |
| for ( var i = 0, l = groups.length; i < l; i ++ ) { | |
| var group = groups[ i ]; | |
| this.addGroup( group.start, group.count, group.instances ); | |
| } | |
| return this; | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.InstancedBufferGeometry.prototype ); | |
| // File:src/core/Uniform.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Uniform = function ( type, value ) { | |
| this.type = type; | |
| this.value = value; | |
| this.dynamic = false; | |
| }; | |
| THREE.Uniform.prototype = { | |
| constructor: THREE.Uniform, | |
| onUpdate: function ( callback ) { | |
| this.dynamic = true; | |
| this.onUpdateCallback = callback; | |
| return this; | |
| } | |
| }; | |
| // File:src/animation/AnimationClip.js | |
| /** | |
| * | |
| * Reusable set of Tracks that represent an animation. | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| */ | |
| THREE.AnimationClip = function ( name, duration, tracks ) { | |
| this.name = name || THREE.Math.generateUUID(); | |
| this.tracks = tracks; | |
| this.duration = ( duration !== undefined ) ? duration : -1; | |
| // this means it should figure out its duration by scanning the tracks | |
| if ( this.duration < 0 ) { | |
| this.resetDuration(); | |
| } | |
| // maybe only do these on demand, as doing them here could potentially slow down loading | |
| // but leaving these here during development as this ensures a lot of testing of these functions | |
| this.trim(); | |
| this.optimize(); | |
| }; | |
| THREE.AnimationClip.prototype = { | |
| constructor: THREE.AnimationClip, | |
| resetDuration: function() { | |
| var tracks = this.tracks, | |
| duration = 0; | |
| for ( var i = 0, n = tracks.length; i !== n; ++ i ) { | |
| var track = this.tracks[ i ]; | |
| duration = Math.max( | |
| duration, track.times[ track.times.length - 1 ] ); | |
| } | |
| this.duration = duration; | |
| }, | |
| trim: function() { | |
| for ( var i = 0; i < this.tracks.length; i ++ ) { | |
| this.tracks[ i ].trim( 0, this.duration ); | |
| } | |
| return this; | |
| }, | |
| optimize: function() { | |
| for ( var i = 0; i < this.tracks.length; i ++ ) { | |
| this.tracks[ i ].optimize(); | |
| } | |
| return this; | |
| } | |
| }; | |
| // Static methods: | |
| Object.assign( THREE.AnimationClip, { | |
| parse: function( json ) { | |
| var tracks = [], | |
| jsonTracks = json.tracks, | |
| frameTime = 1.0 / ( json.fps || 1.0 ); | |
| for ( var i = 0, n = jsonTracks.length; i !== n; ++ i ) { | |
| tracks.push( THREE.KeyframeTrack.parse( jsonTracks[ i ] ).scale( frameTime ) ); | |
| } | |
| return new THREE.AnimationClip( json.name, json.duration, tracks ); | |
| }, | |
| toJSON: function( clip ) { | |
| var tracks = [], | |
| clipTracks = clip.tracks; | |
| var json = { | |
| 'name': clip.name, | |
| 'duration': clip.duration, | |
| 'tracks': tracks | |
| }; | |
| for ( var i = 0, n = clipTracks.length; i !== n; ++ i ) { | |
| tracks.push( THREE.KeyframeTrack.toJSON( clipTracks[ i ] ) ); | |
| } | |
| return json; | |
| }, | |
| CreateFromMorphTargetSequence: function( name, morphTargetSequence, fps ) { | |
| var numMorphTargets = morphTargetSequence.length; | |
| var tracks = []; | |
| for ( var i = 0; i < numMorphTargets; i ++ ) { | |
| var times = []; | |
| var values = []; | |
| times.push( | |
| ( i + numMorphTargets - 1 ) % numMorphTargets, | |
| i, | |
| ( i + 1 ) % numMorphTargets ); | |
| values.push( 0, 1, 0 ); | |
| var order = THREE.AnimationUtils.getKeyframeOrder( times ); | |
| times = THREE.AnimationUtils.sortedArray( times, 1, order ); | |
| values = THREE.AnimationUtils.sortedArray( values, 1, order ); | |
| // if there is a key at the first frame, duplicate it as the | |
| // last frame as well for perfect loop. | |
| if ( times[ 0 ] === 0 ) { | |
| times.push( numMorphTargets ); | |
| values.push( values[ 0 ] ); | |
| } | |
| tracks.push( | |
| new THREE.NumberKeyframeTrack( | |
| '.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']', | |
| times, values | |
| ).scale( 1.0 / fps ) ); | |
| } | |
| return new THREE.AnimationClip( name, -1, tracks ); | |
| }, | |
| findByName: function( clipArray, name ) { | |
| for ( var i = 0; i < clipArray.length; i ++ ) { | |
| if ( clipArray[ i ].name === name ) { | |
| return clipArray[ i ]; | |
| } | |
| } | |
| return null; | |
| }, | |
| CreateClipsFromMorphTargetSequences: function( morphTargets, fps ) { | |
| var animationToMorphTargets = {}; | |
| // tested with https://regex101.com/ on trick sequences | |
| // such flamingo_flyA_003, flamingo_run1_003, crdeath0059 | |
| var pattern = /^([\w-]*?)([\d]+)$/; | |
| // sort morph target names into animation groups based | |
| // patterns like Walk_001, Walk_002, Run_001, Run_002 | |
| for ( var i = 0, il = morphTargets.length; i < il; i ++ ) { | |
| var morphTarget = morphTargets[ i ]; | |
| var parts = morphTarget.name.match( pattern ); | |
| if ( parts && parts.length > 1 ) { | |
| var name = parts[ 1 ]; | |
| var animationMorphTargets = animationToMorphTargets[ name ]; | |
| if ( ! animationMorphTargets ) { | |
| animationToMorphTargets[ name ] = animationMorphTargets = []; | |
| } | |
| animationMorphTargets.push( morphTarget ); | |
| } | |
| } | |
| var clips = []; | |
| for ( var name in animationToMorphTargets ) { | |
| clips.push( THREE.AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps ) ); | |
| } | |
| return clips; | |
| }, | |
| // parse the animation.hierarchy format | |
| parseAnimation: function( animation, bones, nodeName ) { | |
| if ( ! animation ) { | |
| console.error( " no animation in JSONLoader data" ); | |
| return null; | |
| } | |
| var addNonemptyTrack = function( | |
| trackType, trackName, animationKeys, propertyName, destTracks ) { | |
| // only return track if there are actually keys. | |
| if ( animationKeys.length !== 0 ) { | |
| var times = []; | |
| var values = []; | |
| THREE.AnimationUtils.flattenJSON( | |
| animationKeys, times, values, propertyName ); | |
| // empty keys are filtered out, so check again | |
| if ( times.length !== 0 ) { | |
| destTracks.push( new trackType( trackName, times, values ) ); | |
| } | |
| } | |
| }; | |
| var tracks = []; | |
| var clipName = animation.name || 'default'; | |
| // automatic length determination in AnimationClip. | |
| var duration = animation.length || -1; | |
| var fps = animation.fps || 30; | |
| var hierarchyTracks = animation.hierarchy || []; | |
| for ( var h = 0; h < hierarchyTracks.length; h ++ ) { | |
| var animationKeys = hierarchyTracks[ h ].keys; | |
| // skip empty tracks | |
| if ( ! animationKeys || animationKeys.length == 0 ) continue; | |
| // process morph targets in a way exactly compatible | |
| // with AnimationHandler.init( animation ) | |
| if ( animationKeys[0].morphTargets ) { | |
| // figure out all morph targets used in this track | |
| var morphTargetNames = {}; | |
| for ( var k = 0; k < animationKeys.length; k ++ ) { | |
| if ( animationKeys[k].morphTargets ) { | |
| for ( var m = 0; m < animationKeys[k].morphTargets.length; m ++ ) { | |
| morphTargetNames[ animationKeys[k].morphTargets[m] ] = -1; | |
| } | |
| } | |
| } | |
| // create a track for each morph target with all zero | |
| // morphTargetInfluences except for the keys in which | |
| // the morphTarget is named. | |
| for ( var morphTargetName in morphTargetNames ) { | |
| var times = []; | |
| var values = []; | |
| for ( var m = 0; | |
| m !== animationKeys[k].morphTargets.length; ++ m ) { | |
| var animationKey = animationKeys[k]; | |
| times.push( animationKey.time ); | |
| values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 ) | |
| } | |
| tracks.push( new THREE.NumberKeyframeTrack( | |
| '.morphTargetInfluence[' + morphTargetName + ']', times, values ) ); | |
| } | |
| duration = morphTargetNames.length * ( fps || 1.0 ); | |
| } else { | |
| // ...assume skeletal animation | |
| var boneName = '.bones[' + bones[ h ].name + ']'; | |
| addNonemptyTrack( | |
| THREE.VectorKeyframeTrack, boneName + '.position', | |
| animationKeys, 'pos', tracks ); | |
| addNonemptyTrack( | |
| THREE.QuaternionKeyframeTrack, boneName + '.quaternion', | |
| animationKeys, 'rot', tracks ); | |
| addNonemptyTrack( | |
| THREE.VectorKeyframeTrack, boneName + '.scale', | |
| animationKeys, 'scl', tracks ); | |
| } | |
| } | |
| if ( tracks.length === 0 ) { | |
| return null; | |
| } | |
| var clip = new THREE.AnimationClip( clipName, duration, tracks ); | |
| return clip; | |
| } | |
| } ); | |
| // File:src/animation/AnimationMixer.js | |
| /** | |
| * | |
| * Player for AnimationClips. | |
| * | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.AnimationMixer = function( root ) { | |
| this._root = root; | |
| this._initMemoryManager(); | |
| this._accuIndex = 0; | |
| this.time = 0; | |
| this.timeScale = 1.0; | |
| }; | |
| THREE.AnimationMixer.prototype = { | |
| constructor: THREE.AnimationMixer, | |
| // return an action for a clip optionally using a custom root target | |
| // object (this method allocates a lot of dynamic memory in case a | |
| // previously unknown clip/root combination is specified) | |
| clipAction: function( clip, optionalRoot ) { | |
| var root = optionalRoot || this._root, | |
| rootUuid = root.uuid, | |
| clipName = ( typeof clip === 'string' ) ? clip : clip.name, | |
| clipObject = ( clip !== clipName ) ? clip : null, | |
| actionsForClip = this._actionsByClip[ clipName ], | |
| prototypeAction; | |
| if ( actionsForClip !== undefined ) { | |
| var existingAction = | |
| actionsForClip.actionByRoot[ rootUuid ]; | |
| if ( existingAction !== undefined ) { | |
| return existingAction; | |
| } | |
| // we know the clip, so we don't have to parse all | |
| // the bindings again but can just copy | |
| prototypeAction = actionsForClip.knownActions[ 0 ]; | |
| // also, take the clip from the prototype action | |
| clipObject = prototypeAction._clip; | |
| if ( clip !== clipName && clip !== clipObject ) { | |
| throw new Error( | |
| "Different clips with the same name detected!" ); | |
| } | |
| } | |
| // clip must be known when specified via string | |
| if ( clipObject === null ) return null; | |
| // allocate all resources required to run it | |
| var newAction = new THREE. | |
| AnimationMixer._Action( this, clipObject, optionalRoot ); | |
| this._bindAction( newAction, prototypeAction ); | |
| // and make the action known to the memory manager | |
| this._addInactiveAction( newAction, clipName, rootUuid ); | |
| return newAction; | |
| }, | |
| // get an existing action | |
| existingAction: function( clip, optionalRoot ) { | |
| var root = optionalRoot || this._root, | |
| rootUuid = root.uuid, | |
| clipName = ( typeof clip === 'string' ) ? clip : clip.name, | |
| actionsForClip = this._actionsByClip[ clipName ]; | |
| if ( actionsForClip !== undefined ) { | |
| return actionsForClip.actionByRoot[ rootUuid ] || null; | |
| } | |
| return null; | |
| }, | |
| // deactivates all previously scheduled actions | |
| stopAllAction: function() { | |
| var actions = this._actions, | |
| nActions = this._nActiveActions, | |
| bindings = this._bindings, | |
| nBindings = this._nActiveBindings; | |
| this._nActiveActions = 0; | |
| this._nActiveBindings = 0; | |
| for ( var i = 0; i !== nActions; ++ i ) { | |
| actions[ i ].reset(); | |
| } | |
| for ( var i = 0; i !== nBindings; ++ i ) { | |
| bindings[ i ].useCount = 0; | |
| } | |
| return this; | |
| }, | |
| // advance the time and update apply the animation | |
| update: function( deltaTime ) { | |
| deltaTime *= this.timeScale; | |
| var actions = this._actions, | |
| nActions = this._nActiveActions, | |
| time = this.time += deltaTime, | |
| timeDirection = Math.sign( deltaTime ), | |
| accuIndex = this._accuIndex ^= 1; | |
| // run active actions | |
| for ( var i = 0; i !== nActions; ++ i ) { | |
| var action = actions[ i ]; | |
| if ( action.enabled ) { | |
| action._update( time, deltaTime, timeDirection, accuIndex ); | |
| } | |
| } | |
| // update scene graph | |
| var bindings = this._bindings, | |
| nBindings = this._nActiveBindings; | |
| for ( var i = 0; i !== nBindings; ++ i ) { | |
| bindings[ i ].apply( accuIndex ); | |
| } | |
| return this; | |
| }, | |
| // return this mixer's root target object | |
| getRoot: function() { | |
| return this._root; | |
| }, | |
| // free all resources specific to a particular clip | |
| uncacheClip: function( clip ) { | |
| var actions = this._actions, | |
| clipName = clip.name, | |
| actionsByClip = this._actionsByClip, | |
| actionsForClip = actionsByClip[ clipName ]; | |
| if ( actionsForClip !== undefined ) { | |
| // note: just calling _removeInactiveAction would mess up the | |
| // iteration state and also require updating the state we can | |
| // just throw away | |
| var actionsToRemove = actionsForClip.knownActions; | |
| for ( var i = 0, n = actionsToRemove.length; i !== n; ++ i ) { | |
| var action = actionsToRemove[ i ]; | |
| this._deactivateAction( action ); | |
| var cacheIndex = action._cacheIndex, | |
| lastInactiveAction = actions[ actions.length - 1 ]; | |
| action._cacheIndex = null; | |
| action._byClipCacheIndex = null; | |
| lastInactiveAction._cacheIndex = cacheIndex; | |
| actions[ cacheIndex ] = lastInactiveAction; | |
| actions.pop(); | |
| this._removeInactiveBindingsForAction( action ); | |
| } | |
| delete actionsByClip[ clipName ]; | |
| } | |
| }, | |
| // free all resources specific to a particular root target object | |
| uncacheRoot: function( root ) { | |
| var rootUuid = root.uuid, | |
| actionsByClip = this._actionsByClip; | |
| for ( var clipName in actionsByClip ) { | |
| var actionByRoot = actionsByClip[ clipName ].actionByRoot, | |
| action = actionByRoot[ rootUuid ]; | |
| if ( action !== undefined ) { | |
| this._deactivateAction( action ); | |
| this._removeInactiveAction( action ); | |
| } | |
| } | |
| var bindingsByRoot = this._bindingsByRootAndName, | |
| bindingByName = bindingsByRoot[ rootUuid ]; | |
| if ( bindingByName !== undefined ) { | |
| for ( var trackName in bindingByName ) { | |
| var binding = bindingByName[ trackName ]; | |
| binding.restoreOriginalState(); | |
| this._removeInactiveBinding( binding ); | |
| } | |
| } | |
| }, | |
| // remove a targeted clip from the cache | |
| uncacheAction: function( clip, optionalRoot ) { | |
| var action = this.existingAction( clip, optionalRoot ); | |
| if ( action !== null ) { | |
| this._deactivateAction( action ); | |
| this._removeInactiveAction( action ); | |
| } | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.AnimationMixer.prototype ); | |
| THREE.AnimationMixer._Action = | |
| function( mixer, clip, localRoot ) { | |
| this._mixer = mixer; | |
| this._clip = clip; | |
| this._localRoot = localRoot || null; | |
| var tracks = clip.tracks, | |
| nTracks = tracks.length, | |
| interpolants = new Array( nTracks ); | |
| var interpolantSettings = { | |
| endingStart: THREE.ZeroCurvatureEnding, | |
| endingEnd: THREE.ZeroCurvatureEnding | |
| }; | |
| for ( var i = 0; i !== nTracks; ++ i ) { | |
| var interpolant = tracks[ i ].createInterpolant( null ); | |
| interpolants[ i ] = interpolant; | |
| interpolant.settings = interpolantSettings | |
| } | |
| this._interpolantSettings = interpolantSettings; | |
| this._interpolants = interpolants; // bound by the mixer | |
| // inside: PropertyMixer (managed by the mixer) | |
| this._propertyBindings = new Array( nTracks ); | |
| this._cacheIndex = null; // for the memory manager | |
| this._byClipCacheIndex = null; // for the memory manager | |
| this._timeScaleInterpolant = null; | |
| this._weightInterpolant = null; | |
| this.loop = THREE.LoopRepeat; | |
| this._loopCount = -1; | |
| // global mixer time when the action is to be started | |
| // it's set back to 'null' upon start of the action | |
| this._startTime = null; | |
| // scaled local time of the action | |
| // gets clamped or wrapped to 0..clip.duration according to loop | |
| this.time = 0; | |
| this.timeScale = 1; | |
| this._effectiveTimeScale = 1; | |
| this.weight = 1; | |
| this._effectiveWeight = 1; | |
| this.repetitions = Infinity; // no. of repetitions when looping | |
| this.paused = false; // false -> zero effective time scale | |
| this.enabled = true; // true -> zero effective weight | |
| this.clampWhenFinished = false; // keep feeding the last frame? | |
| this.zeroSlopeAtStart = true; // for smooth interpolation w/o separate | |
| this.zeroSlopeAtEnd = true; // clips for start, loop and end | |
| }; | |
| THREE.AnimationMixer._Action.prototype = { | |
| constructor: THREE.AnimationMixer._Action, | |
| // State & Scheduling | |
| play: function() { | |
| this._mixer._activateAction( this ); | |
| return this; | |
| }, | |
| stop: function() { | |
| this._mixer._deactivateAction( this ); | |
| return this.reset(); | |
| }, | |
| reset: function() { | |
| this.paused = false; | |
| this.enabled = true; | |
| this.time = 0; // restart clip | |
| this._loopCount = -1; // forget previous loops | |
| this._startTime = null; // forget scheduling | |
| return this.stopFading().stopWarping(); | |
| }, | |
| isRunning: function() { | |
| var start = this._startTime; | |
| return this.enabled && ! this.paused && this.timeScale !== 0 && | |
| this._startTime === null && this._mixer._isActiveAction( this ) | |
| }, | |
| // return true when play has been called | |
| isScheduled: function() { | |
| return this._mixer._isActiveAction( this ); | |
| }, | |
| startAt: function( time ) { | |
| this._startTime = time; | |
| return this; | |
| }, | |
| setLoop: function( mode, repetitions ) { | |
| this.loop = mode; | |
| this.repetitions = repetitions; | |
| return this; | |
| }, | |
| // Weight | |
| // set the weight stopping any scheduled fading | |
| // although .enabled = false yields an effective weight of zero, this | |
| // method does *not* change .enabled, because it would be confusing | |
| setEffectiveWeight: function( weight ) { | |
| this.weight = weight; | |
| // note: same logic as when updated at runtime | |
| this._effectiveWeight = this.enabled ? weight : 0; | |
| return this.stopFading(); | |
| }, | |
| // return the weight considering fading and .enabled | |
| getEffectiveWeight: function() { | |
| return this._effectiveWeight; | |
| }, | |
| fadeIn: function( duration ) { | |
| return this._scheduleFading( duration, 0, 1 ); | |
| }, | |
| fadeOut: function( duration ) { | |
| return this._scheduleFading( duration, 1, 0 ); | |
| }, | |
| crossFadeFrom: function( fadeOutAction, duration, warp ) { | |
| var mixer = this._mixer; | |
| fadeOutAction.fadeOut( duration ); | |
| this.fadeIn( duration ); | |
| if( warp ) { | |
| var fadeInDuration = this._clip.duration, | |
| fadeOutDuration = fadeOutAction._clip.duration, | |
| startEndRatio = fadeOutDuration / fadeInDuration, | |
| endStartRatio = fadeInDuration / fadeOutDuration; | |
| fadeOutAction.warp( 1.0, startEndRatio, duration ); | |
| this.warp( endStartRatio, 1.0, duration ); | |
| } | |
| return this; | |
| }, | |
| crossFadeTo: function( fadeInAction, duration, warp ) { | |
| return fadeInAction.crossFadeFrom( this, duration, warp ); | |
| }, | |
| stopFading: function() { | |
| var weightInterpolant = this._weightInterpolant; | |
| if ( weightInterpolant !== null ) { | |
| this._weightInterpolant = null; | |
| this._mixer._takeBackControlInterpolant( weightInterpolant ); | |
| } | |
| return this; | |
| }, | |
| // Time Scale Control | |
| // set the weight stopping any scheduled warping | |
| // although .paused = true yields an effective time scale of zero, this | |
| // method does *not* change .paused, because it would be confusing | |
| setEffectiveTimeScale: function( timeScale ) { | |
| this.timeScale = timeScale; | |
| this._effectiveTimeScale = this.paused ? 0 :timeScale; | |
| return this.stopWarping(); | |
| }, | |
| // return the time scale considering warping and .paused | |
| getEffectiveTimeScale: function() { | |
| return this._effectiveTimeScale; | |
| }, | |
| setDuration: function( duration ) { | |
| this.timeScale = this._clip.duration / duration; | |
| return this.stopWarping(); | |
| }, | |
| syncWith: function( action ) { | |
| this.time = action.time; | |
| this.timeScale = action.timeScale; | |
| return this.stopWarping(); | |
| }, | |
| halt: function( duration ) { | |
| return this.warp( this._currentTimeScale, 0, duration ); | |
| }, | |
| warp: function( startTimeScale, endTimeScale, duration ) { | |
| var mixer = this._mixer, now = mixer.time, | |
| interpolant = this._timeScaleInterpolant, | |
| timeScale = this.timeScale; | |
| if ( interpolant === null ) { | |
| interpolant = mixer._lendControlInterpolant(), | |
| this._timeScaleInterpolant = interpolant; | |
| } | |
| var times = interpolant.parameterPositions, | |
| values = interpolant.sampleValues; | |
| times[ 0 ] = now; | |
| times[ 1 ] = now + duration; | |
| values[ 0 ] = startTimeScale / timeScale; | |
| values[ 1 ] = endTimeScale / timeScale; | |
| return this; | |
| }, | |
| stopWarping: function() { | |
| var timeScaleInterpolant = this._timeScaleInterpolant; | |
| if ( timeScaleInterpolant !== null ) { | |
| this._timeScaleInterpolant = null; | |
| this._mixer._takeBackControlInterpolant( timeScaleInterpolant ); | |
| } | |
| return this; | |
| }, | |
| // Object Accessors | |
| getMixer: function() { | |
| return this._mixer; | |
| }, | |
| getClip: function() { | |
| return this._clip; | |
| }, | |
| getRoot: function() { | |
| return this._localRoot || this._mixer._root; | |
| }, | |
| // Interna | |
| _update: function( time, deltaTime, timeDirection, accuIndex ) { | |
| // called by the mixer | |
| var startTime = this._startTime; | |
| if ( startTime !== null ) { | |
| // check for scheduled start of action | |
| var timeRunning = ( time - startTime ) * timeDirection; | |
| if ( timeRunning < 0 || timeDirection === 0 ) { | |
| return; // yet to come / don't decide when delta = 0 | |
| } | |
| // start | |
| this._startTime = null; // unschedule | |
| deltaTime = timeDirection * timeRunning; | |
| } | |
| // apply time scale and advance time | |
| deltaTime *= this._updateTimeScale( time ); | |
| var clipTime = this._updateTime( deltaTime ); | |
| // note: _updateTime may disable the action resulting in | |
| // an effective weight of 0 | |
| var weight = this._updateWeight( time ); | |
| if ( weight > 0 ) { | |
| var interpolants = this._interpolants; | |
| var propertyMixers = this._propertyBindings; | |
| for ( var j = 0, m = interpolants.length; j !== m; ++ j ) { | |
| interpolants[ j ].evaluate( clipTime ); | |
| propertyMixers[ j ].accumulate( accuIndex, weight ); | |
| } | |
| } | |
| }, | |
| _updateWeight: function( time ) { | |
| var weight = 0; | |
| if ( this.enabled ) { | |
| weight = this.weight; | |
| var interpolant = this._weightInterpolant; | |
| if ( interpolant !== null ) { | |
| var interpolantValue = interpolant.evaluate( time )[ 0 ]; | |
| weight *= interpolantValue; | |
| if ( time > interpolant.parameterPositions[ 1 ] ) { | |
| this.stopFading(); | |
| if ( interpolantValue === 0 ) { | |
| // faded out, disable | |
| this.enabled = false; | |
| } | |
| } | |
| } | |
| } | |
| this._effectiveWeight = weight; | |
| return weight; | |
| }, | |
| _updateTimeScale: function( time ) { | |
| var timeScale = 0; | |
| if ( ! this.paused ) { | |
| timeScale = this.timeScale; | |
| var interpolant = this._timeScaleInterpolant; | |
| if ( interpolant !== null ) { | |
| var interpolantValue = interpolant.evaluate( time )[ 0 ]; | |
| timeScale *= interpolantValue; | |
| if ( time > interpolant.parameterPositions[ 1 ] ) { | |
| this.stopWarping(); | |
| if ( timeScale === 0 ) { | |
| // motion has halted, pause | |
| this.pause = true; | |
| } else { | |
| // warp done - apply final time scale | |
| this.timeScale = timeScale; | |
| } | |
| } | |
| } | |
| } | |
| this._effectiveTimeScale = timeScale; | |
| return timeScale; | |
| }, | |
| _updateTime: function( deltaTime ) { | |
| var time = this.time + deltaTime; | |
| if ( deltaTime === 0 ) return time; | |
| var duration = this._clip.duration, | |
| loop = this.loop, | |
| loopCount = this._loopCount, | |
| pingPong = false; | |
| switch ( loop ) { | |
| case THREE.LoopOnce: | |
| if ( loopCount === -1 ) { | |
| // just started | |
| this.loopCount = 0; | |
| this._setEndings( true, true, false ); | |
| } | |
| if ( time >= duration ) { | |
| time = duration; | |
| } else if ( time < 0 ) { | |
| time = 0; | |
| } else break; | |
| // reached the end | |
| if ( this.clampWhenFinished ) this.pause = true; | |
| else this.enabled = false; | |
| this._mixer.dispatchEvent( { | |
| type: 'finished', action: this, | |
| direction: deltaTime < 0 ? -1 : 1 | |
| } ); | |
| break; | |
| case THREE.LoopPingPong: | |
| pingPong = true; | |
| case THREE.LoopRepeat: | |
| if ( loopCount === -1 ) { | |
| // just started | |
| if ( deltaTime > 0 ) { | |
| loopCount = 0; | |
| this._setEndings( | |
| true, this.repetitions === 0, pingPong ); | |
| } else { | |
| // when looping in reverse direction, the initial | |
| // transition through zero counts as a repetition, | |
| // so leave loopCount at -1 | |
| this._setEndings( | |
| this.repetitions === 0, true, pingPong ); | |
| } | |
| } | |
| if ( time >= duration || time < 0 ) { | |
| // wrap around | |
| var loopDelta = Math.floor( time / duration ); // signed | |
| time -= duration * loopDelta; | |
| loopCount += Math.abs( loopDelta ); | |
| var pending = this.repetitions - loopCount; | |
| if ( pending < 0 ) { | |
| // stop (switch state, clamp time, fire event) | |
| if ( this.clampWhenFinished ) this.paused = true; | |
| else this.enabled = false; | |
| time = deltaTime > 0 ? duration : 0; | |
| this._mixer.dispatchEvent( { | |
| type: 'finished', action: this, | |
| direction: deltaTime > 0 ? 1 : -1 | |
| } ); | |
| break; | |
| } else if ( pending === 0 ) { | |
| // transition to last round | |
| var atStart = deltaTime < 0; | |
| this._setEndings( atStart, ! atStart, pingPong ); | |
| } else { | |
| this._setEndings( false, false, pingPong ); | |
| } | |
| this._loopCount = loopCount; | |
| this._mixer.dispatchEvent( { | |
| type: 'loop', action: this, loopDelta: loopDelta | |
| } ); | |
| } | |
| if ( loop === THREE.LoopPingPong && ( loopCount & 1 ) === 1 ) { | |
| // invert time for the "pong round" | |
| this.time = time; | |
| return duration - time; | |
| } | |
| break; | |
| } | |
| this.time = time; | |
| return time; | |
| }, | |
| _setEndings: function( atStart, atEnd, pingPong ) { | |
| var settings = this._interpolantSettings; | |
| if ( pingPong ) { | |
| settings.endingStart = THREE.ZeroSlopeEnding; | |
| settings.endingEnd = THREE.ZeroSlopeEnding; | |
| } else { | |
| // assuming for LoopOnce atStart == atEnd == true | |
| if ( atStart ) { | |
| settings.endingStart = this.zeroSlopeAtStart ? | |
| THREE.ZeroSlopeEnding : THREE.ZeroCurvatureEnding; | |
| } else { | |
| settings.endingStart = THREE.WrapAroundEnding; | |
| } | |
| if ( atEnd ) { | |
| settings.endingEnd = this.zeroSlopeAtEnd ? | |
| THREE.ZeroSlopeEnding : THREE.ZeroCurvatureEnding; | |
| } else { | |
| settings.endingEnd = THREE.WrapAroundEnding; | |
| } | |
| } | |
| }, | |
| _scheduleFading: function( duration, weightNow, weightThen ) { | |
| var mixer = this._mixer, now = mixer.time, | |
| interpolant = this._weightInterpolant; | |
| if ( interpolant === null ) { | |
| interpolant = mixer._lendControlInterpolant(), | |
| this._weightInterpolant = interpolant; | |
| } | |
| var times = interpolant.parameterPositions, | |
| values = interpolant.sampleValues; | |
| times[ 0 ] = now; values[ 0 ] = weightNow; | |
| times[ 1 ] = now + duration; values[ 1 ] = weightThen; | |
| return this; | |
| } | |
| }; | |
| // Implementation details: | |
| Object.assign( THREE.AnimationMixer.prototype, { | |
| _bindAction: function( action, prototypeAction ) { | |
| var root = action._localRoot || this._root, | |
| tracks = action._clip.tracks, | |
| nTracks = tracks.length, | |
| bindings = action._propertyBindings, | |
| interpolants = action._interpolants, | |
| rootUuid = root.uuid, | |
| bindingsByRoot = this._bindingsByRootAndName, | |
| bindingsByName = bindingsByRoot[ rootUuid ]; | |
| if ( bindingsByName === undefined ) { | |
| bindingsByName = {}; | |
| bindingsByRoot[ rootUuid ] = bindingsByName; | |
| } | |
| for ( var i = 0; i !== nTracks; ++ i ) { | |
| var track = tracks[ i ], | |
| trackName = track.name, | |
| binding = bindingsByName[ trackName ]; | |
| if ( binding !== undefined ) { | |
| bindings[ i ] = binding; | |
| } else { | |
| binding = bindings[ i ]; | |
| if ( binding !== undefined ) { | |
| // existing binding, make sure the cache knows | |
| if ( binding._cacheIndex === null ) { | |
| ++ binding.referenceCount; | |
| this._addInactiveBinding( binding, rootUuid, trackName ); | |
| } | |
| continue; | |
| } | |
| var path = prototypeAction && prototypeAction. | |
| _propertyBindings[ i ].binding.parsedPath; | |
| binding = new THREE.PropertyMixer( | |
| THREE.PropertyBinding.create( root, trackName, path ), | |
| track.ValueTypeName, track.getValueSize() ); | |
| ++ binding.referenceCount; | |
| this._addInactiveBinding( binding, rootUuid, trackName ); | |
| bindings[ i ] = binding; | |
| } | |
| interpolants[ i ].resultBuffer = binding.buffer; | |
| } | |
| }, | |
| _activateAction: function( action ) { | |
| if ( ! this._isActiveAction( action ) ) { | |
| if ( action._cacheIndex === null ) { | |
| // this action has been forgotten by the cache, but the user | |
| // appears to be still using it -> rebind | |
| var rootUuid = ( action._localRoot || this._root ).uuid, | |
| clipName = action._clip.name, | |
| actionsForClip = this._actionsByClip[ clipName ]; | |
| this._bindAction( action, | |
| actionsForClip && actionsForClip.knownActions[ 0 ] ); | |
| this._addInactiveAction( action, clipName, rootUuid ); | |
| } | |
| var bindings = action._propertyBindings; | |
| // increment reference counts / sort out state | |
| for ( var i = 0, n = bindings.length; i !== n; ++ i ) { | |
| var binding = bindings[ i ]; | |
| if ( binding.useCount ++ === 0 ) { | |
| this._lendBinding( binding ); | |
| binding.saveOriginalState(); | |
| } | |
| } | |
| this._lendAction( action ); | |
| } | |
| }, | |
| _deactivateAction: function( action ) { | |
| if ( this._isActiveAction( action ) ) { | |
| var bindings = action._propertyBindings; | |
| // decrement reference counts / sort out state | |
| for ( var i = 0, n = bindings.length; i !== n; ++ i ) { | |
| var binding = bindings[ i ]; | |
| if ( -- binding.useCount === 0 ) { | |
| binding.restoreOriginalState(); | |
| this._takeBackBinding( binding ); | |
| } | |
| } | |
| this._takeBackAction( action ); | |
| } | |
| }, | |
| // Memory manager | |
| _initMemoryManager: function() { | |
| this._actions = []; // 'nActiveActions' followed by inactive ones | |
| this._nActiveActions = 0; | |
| this._actionsByClip = {}; | |
| // inside: | |
| // { | |
| // knownActions: Array< _Action > - used as prototypes | |
| // actionByRoot: _Action - lookup | |
| // } | |
| this._bindings = []; // 'nActiveBindings' followed by inactive ones | |
| this._nActiveBindings = 0; | |
| this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer > | |
| this._controlInterpolants = []; // same game as above | |
| this._nActiveControlInterpolants = 0; | |
| var scope = this; | |
| this.stats = { | |
| actions: { | |
| get total() { return scope._actions.length; }, | |
| get inUse() { return scope._nActiveActions; } | |
| }, | |
| bindings: { | |
| get total() { return scope._bindings.length; }, | |
| get inUse() { return scope._nActiveBindings; } | |
| }, | |
| controlInterpolants: { | |
| get total() { return scope._controlInterpolants.length; }, | |
| get inUse() { return scope._nActiveControlInterpolants; } | |
| } | |
| }; | |
| }, | |
| // Memory management for _Action objects | |
| _isActiveAction: function( action ) { | |
| var index = action._cacheIndex; | |
| return index !== null && index < this._nActiveActions; | |
| }, | |
| _addInactiveAction: function( action, clipName, rootUuid ) { | |
| var actions = this._actions, | |
| actionsByClip = this._actionsByClip, | |
| actionsForClip = actionsByClip[ clipName ]; | |
| if ( actionsForClip === undefined ) { | |
| actionsForClip = { | |
| knownActions: [ action ], | |
| actionByRoot: {} | |
| }; | |
| action._byClipCacheIndex = 0; | |
| actionsByClip[ clipName ] = actionsForClip; | |
| } else { | |
| var knownActions = actionsForClip.knownActions; | |
| action._byClipCacheIndex = knownActions.length; | |
| knownActions.push( action ); | |
| } | |
| action._cacheIndex = actions.length; | |
| actions.push( action ); | |
| actionsForClip.actionByRoot[ rootUuid ] = action; | |
| }, | |
| _removeInactiveAction: function( action ) { | |
| var actions = this._actions, | |
| lastInactiveAction = actions[ actions.length - 1 ], | |
| cacheIndex = action._cacheIndex; | |
| lastInactiveAction._cacheIndex = cacheIndex; | |
| actions[ cacheIndex ] = lastInactiveAction; | |
| actions.pop(); | |
| action._cacheIndex = null; | |
| var clipName = action._clip.name, | |
| actionsByClip = this._actionsByClip, | |
| actionsForClip = actionsByClip[ clipName ], | |
| knownActionsForClip = actionsForClip.knownActions, | |
| lastKnownAction = | |
| knownActionsForClip[ knownActionsForClip.length - 1 ], | |
| byClipCacheIndex = action._byClipCacheIndex; | |
| lastKnownAction._byClipCacheIndex = byClipCacheIndex; | |
| knownActionsForClip[ byClipCacheIndex ] = lastKnownAction; | |
| knownActionsForClip.pop(); | |
| action._byClipCacheIndex = null; | |
| var actionByRoot = actionsForClip.actionByRoot, | |
| rootUuid = ( actions._localRoot || this._root ).uuid; | |
| delete actionByRoot[ rootUuid ]; | |
| if ( knownActionsForClip.length === 0 ) { | |
| delete actionsByClip[ clipName ]; | |
| } | |
| this._removeInactiveBindingsForAction( action ); | |
| }, | |
| _removeInactiveBindingsForAction: function( action ) { | |
| var bindings = action._propertyBindings; | |
| for ( var i = 0, n = bindings.length; i !== n; ++ i ) { | |
| var binding = bindings[ i ]; | |
| if ( -- binding.referenceCount === 0 ) { | |
| this._removeInactiveBinding( binding ); | |
| } | |
| } | |
| }, | |
| _lendAction: function( action ) { | |
| // [ active actions | inactive actions ] | |
| // [ active actions >| inactive actions ] | |
| // s a | |
| // <-swap-> | |
| // a s | |
| var actions = this._actions, | |
| prevIndex = action._cacheIndex, | |
| lastActiveIndex = this._nActiveActions ++, | |
| firstInactiveAction = actions[ lastActiveIndex ]; | |
| action._cacheIndex = lastActiveIndex; | |
| actions[ lastActiveIndex ] = action; | |
| firstInactiveAction._cacheIndex = prevIndex; | |
| actions[ prevIndex ] = firstInactiveAction; | |
| }, | |
| _takeBackAction: function( action ) { | |
| // [ active actions | inactive actions ] | |
| // [ active actions |< inactive actions ] | |
| // a s | |
| // <-swap-> | |
| // s a | |
| var actions = this._actions, | |
| prevIndex = action._cacheIndex, | |
| firstInactiveIndex = -- this._nActiveActions, | |
| lastActiveAction = actions[ firstInactiveIndex ]; | |
| action._cacheIndex = firstInactiveIndex; | |
| actions[ firstInactiveIndex ] = action; | |
| lastActiveAction._cacheIndex = prevIndex; | |
| actions[ prevIndex ] = lastActiveAction; | |
| }, | |
| // Memory management for PropertyMixer objects | |
| _addInactiveBinding: function( binding, rootUuid, trackName ) { | |
| var bindingsByRoot = this._bindingsByRootAndName, | |
| bindingByName = bindingsByRoot[ rootUuid ], | |
| bindings = this._bindings; | |
| if ( bindingByName === undefined ) { | |
| bindingByName = {}; | |
| bindingsByRoot[ rootUuid ] = bindingByName; | |
| } | |
| bindingByName[ trackName ] = binding; | |
| binding._cacheIndex = bindings.length; | |
| bindings.push( binding ); | |
| }, | |
| _removeInactiveBinding: function( binding ) { | |
| var bindings = this._bindings, | |
| propBinding = binding.binding, | |
| rootUuid = propBinding.rootNode.uuid, | |
| trackName = propBinding.path, | |
| bindingsByRoot = this._bindingsByRootAndName, | |
| bindingByName = bindingsByRoot[ rootUuid ], | |
| lastInactiveBinding = bindings[ bindings.length - 1 ], | |
| cacheIndex = binding._cacheIndex; | |
| lastInactiveBinding._cacheIndex = cacheIndex; | |
| bindings[ cacheIndex ] = lastInactiveBinding; | |
| bindings.pop(); | |
| delete bindingByName[ trackName ]; | |
| remove_empty_map: { | |
| for ( var _ in bindingByName ) break remove_empty_map; | |
| delete bindingsByRoot[ rootUuid ]; | |
| } | |
| }, | |
| _lendBinding: function( binding ) { | |
| var bindings = this._bindings, | |
| prevIndex = binding._cacheIndex, | |
| lastActiveIndex = this._nActiveBindings ++, | |
| firstInactiveBinding = bindings[ lastActiveIndex ]; | |
| binding._cacheIndex = lastActiveIndex; | |
| bindings[ lastActiveIndex ] = binding; | |
| firstInactiveBinding._cacheIndex = prevIndex; | |
| bindings[ prevIndex ] = firstInactiveBinding; | |
| }, | |
| _takeBackBinding: function( binding ) { | |
| var bindings = this._bindings, | |
| prevIndex = binding._cacheIndex, | |
| firstInactiveIndex = -- this._nActiveBindings, | |
| lastActiveBinding = bindings[ firstInactiveIndex ]; | |
| binding._cacheIndex = firstInactiveIndex; | |
| bindings[ firstInactiveIndex ] = binding; | |
| lastActiveBinding._cacheIndex = prevIndex; | |
| bindings[ prevIndex ] = lastActiveBinding; | |
| }, | |
| // Memory management of Interpolants for weight and time scale | |
| _lendControlInterpolant: function() { | |
| var interpolants = this._controlInterpolants, | |
| lastActiveIndex = this._nActiveControlInterpolants ++, | |
| interpolant = interpolants[ lastActiveIndex ]; | |
| if ( interpolant === undefined ) { | |
| interpolant = new THREE.LinearInterpolant( | |
| new Float32Array( 2 ), new Float32Array( 2 ), | |
| 1, this._controlInterpolantsResultBuffer ); | |
| interpolant.__cacheIndex = lastActiveIndex; | |
| interpolants[ lastActiveIndex ] = interpolant; | |
| } | |
| return interpolant; | |
| }, | |
| _takeBackControlInterpolant: function( interpolant ) { | |
| var interpolants = this._controlInterpolants, | |
| prevIndex = interpolant.__cacheIndex, | |
| firstInactiveIndex = -- this._nActiveControlInterpolants, | |
| lastActiveInterpolant = interpolants[ firstInactiveIndex ]; | |
| interpolant.__cacheIndex = firstInactiveIndex; | |
| interpolants[ firstInactiveIndex ] = interpolant; | |
| lastActiveInterpolant.__cacheIndex = prevIndex; | |
| interpolants[ prevIndex ] = lastActiveInterpolant; | |
| }, | |
| _controlInterpolantsResultBuffer: new Float32Array( 1 ) | |
| } ); | |
| // File:src/animation/AnimationObjectGroup.js | |
| /** | |
| * | |
| * A group of objects that receives a shared animation state. | |
| * | |
| * Usage: | |
| * | |
| * - Add objects you would otherwise pass as 'root' to the | |
| * constructor or the .clipAction method of AnimationMixer. | |
| * | |
| * - Instead pass this object as 'root'. | |
| * | |
| * - You can also add and remove objects later when the mixer | |
| * is running. | |
| * | |
| * Note: | |
| * | |
| * Objects of this class appear as one object to the mixer, | |
| * so cache control of the individual objects must be done | |
| * on the group. | |
| * | |
| * Limitation: | |
| * | |
| * - The animated properties must be compatible among the | |
| * all objects in the group. | |
| * | |
| * - A single property can either be controlled through a | |
| * target group or directly, but not both. | |
| * | |
| * @author tschw | |
| */ | |
| THREE.AnimationObjectGroup = function( var_args ) { | |
| this.uuid = THREE.Math.generateUUID(); | |
| // cached objects followed by the active ones | |
| this._objects = Array.prototype.slice.call( arguments ); | |
| this.nCachedObjects_ = 0; // threshold | |
| // note: read by PropertyBinding.Composite | |
| var indices = {}; | |
| this._indicesByUUID = indices; // for bookkeeping | |
| for ( var i = 0, n = arguments.length; i !== n; ++ i ) { | |
| indices[ arguments[ i ].uuid ] = i; | |
| } | |
| this._paths = []; // inside: string | |
| this._parsedPaths = []; // inside: { we don't care, here } | |
| this._bindings = []; // inside: Array< PropertyBinding > | |
| this._bindingsIndicesByPath = {}; // inside: indices in these arrays | |
| var scope = this; | |
| this.stats = { | |
| objects: { | |
| get total() { return scope._objects.length; }, | |
| get inUse() { return this.total - scope.nCachedObjects_; } | |
| }, | |
| get bindingsPerObject() { return scope._bindings.length; } | |
| }; | |
| }; | |
| THREE.AnimationObjectGroup.prototype = { | |
| constructor: THREE.AnimationObjectGroup, | |
| add: function( var_args ) { | |
| var objects = this._objects, | |
| nObjects = objects.length, | |
| nCachedObjects = this.nCachedObjects_, | |
| indicesByUUID = this._indicesByUUID, | |
| paths = this._paths, | |
| parsedPaths = this._parsedPaths, | |
| bindings = this._bindings, | |
| nBindings = bindings.length; | |
| for ( var i = 0, n = arguments.length; i !== n; ++ i ) { | |
| var object = arguments[ i ], | |
| uuid = object.uuid, | |
| index = indicesByUUID[ uuid ]; | |
| if ( index === undefined ) { | |
| // unknown object -> add it to the ACTIVE region | |
| index = nObjects ++; | |
| indicesByUUID[ uuid ] = index; | |
| objects.push( object ); | |
| // accounting is done, now do the same for all bindings | |
| for ( var j = 0, m = nBindings; j !== m; ++ j ) { | |
| bindings[ j ].push( | |
| new THREE.PropertyBinding( | |
| object, paths[ j ], parsedPaths[ j ] ) ); | |
| } | |
| } else if ( index < nCachedObjects ) { | |
| var knownObject = objects[ index ]; | |
| // move existing object to the ACTIVE region | |
| var firstActiveIndex = -- nCachedObjects, | |
| lastCachedObject = objects[ firstActiveIndex ]; | |
| indicesByUUID[ lastCachedObject.uuid ] = index; | |
| objects[ index ] = lastCachedObject; | |
| indicesByUUID[ uuid ] = firstActiveIndex; | |
| objects[ firstActiveIndex ] = object; | |
| // accounting is done, now do the same for all bindings | |
| for ( var j = 0, m = nBindings; j !== m; ++ j ) { | |
| var bindingsForPath = bindings[ j ], | |
| lastCached = bindingsForPath[ firstActiveIndex ], | |
| binding = bindingsForPath[ index ]; | |
| bindingsForPath[ index ] = lastCached; | |
| if ( binding === undefined ) { | |
| // since we do not bother to create new bindings | |
| // for objects that are cached, the binding may | |
| // or may not exist | |
| binding = new THREE.PropertyBinding( | |
| object, paths[ j ], parsedPaths[ j ] ); | |
| } | |
| bindingsForPath[ firstActiveIndex ] = binding; | |
| } | |
| } else if ( objects[ index ] !== knownObject) { | |
| console.error( "Different objects with the same UUID " + | |
| "detected. Clean the caches or recreate your " + | |
| "infrastructure when reloading scenes..." ); | |
| } // else the object is already where we want it to be | |
| } // for arguments | |
| this.nCachedObjects_ = nCachedObjects; | |
| }, | |
| remove: function( var_args ) { | |
| var objects = this._objects, | |
| nObjects = objects.length, | |
| nCachedObjects = this.nCachedObjects_, | |
| indicesByUUID = this._indicesByUUID, | |
| bindings = this._bindings, | |
| nBindings = bindings.length; | |
| for ( var i = 0, n = arguments.length; i !== n; ++ i ) { | |
| var object = arguments[ i ], | |
| uuid = object.uuid, | |
| index = indicesByUUID[ uuid ]; | |
| if ( index !== undefined && index >= nCachedObjects ) { | |
| // move existing object into the CACHED region | |
| var lastCachedIndex = nCachedObjects ++, | |
| firstActiveObject = objects[ lastCachedIndex ]; | |
| indicesByUUID[ firstActiveObject.uuid ] = index; | |
| objects[ index ] = firstActiveObject; | |
| indicesByUUID[ uuid ] = lastCachedIndex; | |
| objects[ lastCachedIndex ] = object; | |
| // accounting is done, now do the same for all bindings | |
| for ( var j = 0, m = nBindings; j !== m; ++ j ) { | |
| var bindingsForPath = bindings[ j ], | |
| firstActive = bindingsForPath[ lastCachedIndex ], | |
| binding = bindingsForPath[ index ]; | |
| bindingsForPath[ index ] = firstActive; | |
| bindingsForPath[ lastCachedIndex ] = binding; | |
| } | |
| } | |
| } // for arguments | |
| this.nCachedObjects_ = nCachedObjects; | |
| }, | |
| // remove & forget | |
| uncache: function( var_args ) { | |
| var objects = this._objects, | |
| nObjects = objects.length, | |
| nCachedObjects = this.nCachedObjects_, | |
| indicesByUUID = this._indicesByUUID, | |
| bindings = this._bindings, | |
| nBindings = bindings.length; | |
| for ( var i = 0, n = arguments.length; i !== n; ++ i ) { | |
| var object = arguments[ i ], | |
| uuid = object.uuid, | |
| index = indicesByUUID[ uuid ]; | |
| if ( index !== undefined ) { | |
| delete indicesByUUID[ uuid ]; | |
| if ( index < nCachedObjects ) { | |
| // object is cached, shrink the CACHED region | |
| var firstActiveIndex = -- nCachedObjects, | |
| lastCachedObject = objects[ firstActiveIndex ], | |
| lastIndex = -- nObjects, | |
| lastObject = objects[ lastIndex ]; | |
| // last cached object takes this object's place | |
| indicesByUUID[ lastCachedObject.uuid ] = index; | |
| objects[ index ] = lastCachedObject; | |
| // last object goes to the activated slot and pop | |
| indicesByUUID[ lastObject.uuid ] = firstActiveIndex; | |
| objects[ firstActiveIndex ] = lastObject; | |
| objects.pop(); | |
| // accounting is done, now do the same for all bindings | |
| for ( var j = 0, m = nBindings; j !== m; ++ j ) { | |
| var bindingsForPath = bindings[ j ], | |
| lastCached = bindingsForPath[ firstActiveIndex ], | |
| last = bindingsForPath[ lastIndex ]; | |
| bindingsForPath[ index ] = lastCached; | |
| bindingsForPath[ firstActiveIndex ] = last; | |
| bindingsForPath.pop(); | |
| } | |
| } else { | |
| // object is active, just swap with the last and pop | |
| var lastIndex = -- nObjects, | |
| lastObject = objects[ lastIndex ]; | |
| indicesByUUID[ lastObject.uuid ] = index; | |
| objects[ index ] = lastObject; | |
| objects.pop(); | |
| // accounting is done, now do the same for all bindings | |
| for ( var j = 0, m = nBindings; j !== m; ++ j ) { | |
| var bindingsForPath = bindings[ j ]; | |
| bindingsForPath[ index ] = bindingsForPath[ lastIndex ]; | |
| bindingsForPath.pop(); | |
| } | |
| } // cached or active | |
| } // if object is known | |
| } // for arguments | |
| this.nCachedObjects_ = nCachedObjects; | |
| }, | |
| // Internal interface used by befriended PropertyBinding.Composite: | |
| subscribe_: function( path, parsedPath ) { | |
| // returns an array of bindings for the given path that is changed | |
| // according to the contained objects in the group | |
| var indicesByPath = this._bindingsIndicesByPath, | |
| index = indicesByPath[ path ], | |
| bindings = this._bindings; | |
| if ( index !== undefined ) return bindings[ index ]; | |
| var paths = this._paths, | |
| parsedPaths = this._parsedPaths, | |
| objects = this._objects, | |
| nObjects = objects.length, | |
| nCachedObjects = this.nCachedObjects_, | |
| bindingsForPath = new Array( nObjects ); | |
| index = bindings.length; | |
| indicesByPath[ path ] = index; | |
| paths.push( path ); | |
| parsedPaths.push( parsedPath ); | |
| bindings.push( bindingsForPath ); | |
| for ( var i = nCachedObjects, | |
| n = objects.length; i !== n; ++ i ) { | |
| var object = objects[ i ]; | |
| bindingsForPath[ i ] = | |
| new THREE.PropertyBinding( object, path, parsedPath ); | |
| } | |
| return bindingsForPath; | |
| }, | |
| unsubscribe_: function( path ) { | |
| // tells the group to forget about a property path and no longer | |
| // update the array previously obtained with 'subscribe_' | |
| var indicesByPath = this._bindingsIndicesByPath, | |
| index = indicesByPath[ path ]; | |
| if ( index !== undefined ) { | |
| var paths = this._paths, | |
| parsedPaths = this._parsedPaths, | |
| bindings = this._bindings, | |
| lastBindingsIndex = bindings.length - 1, | |
| lastBindings = bindings[ lastBindingsIndex ], | |
| lastBindingsPath = path[ lastBindingsIndex ]; | |
| indicesByPath[ lastBindingsPath ] = index; | |
| bindings[ index ] = lastBindings; | |
| bindings.pop(); | |
| parsedPaths[ index ] = parsedPaths[ lastBindingsIndex ]; | |
| parsedPaths.pop(); | |
| paths[ index ] = paths[ lastBindingsIndex ]; | |
| paths.pop(); | |
| } | |
| } | |
| }; | |
| // File:src/animation/AnimationUtils.js | |
| /** | |
| * @author tschw | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| */ | |
| THREE.AnimationUtils = { | |
| // same as Array.prototype.slice, but also works on typed arrays | |
| arraySlice: function( array, from, to ) { | |
| if ( THREE.AnimationUtils.isTypedArray( array ) ) { | |
| return new array.constructor( array.subarray( from, to ) ); | |
| } | |
| return array.slice( from, to ); | |
| }, | |
| // converts an array to a specific type | |
| convertArray: function( array, type, forceClone ) { | |
| if ( ! array || // let 'undefined' and 'null' pass | |
| ! forceClone && array.constructor === type ) return array; | |
| if ( typeof type.BYTES_PER_ELEMENT === 'number' ) { | |
| return new type( array ); // create typed array | |
| } | |
| return Array.prototype.slice.call( array ); // create Array | |
| }, | |
| isTypedArray: function( object ) { | |
| return ArrayBuffer.isView( object ) && | |
| ! ( object instanceof DataView ); | |
| }, | |
| // returns an array by which times and values can be sorted | |
| getKeyframeOrder: function( times ) { | |
| function compareTime( i, j ) { | |
| return times[ i ] - times[ j ]; | |
| } | |
| var n = times.length; | |
| var result = new Array( n ); | |
| for ( var i = 0; i !== n; ++ i ) result[ i ] = i; | |
| result.sort( compareTime ); | |
| return result; | |
| }, | |
| // uses the array previously returned by 'getKeyframeOrder' to sort data | |
| sortedArray: function( values, stride, order ) { | |
| var nValues = values.length; | |
| var result = new values.constructor( nValues ); | |
| for ( var i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) { | |
| var srcOffset = order[ i ] * stride; | |
| for ( var j = 0; j !== stride; ++ j ) { | |
| result[ dstOffset ++ ] = values[ srcOffset + j ]; | |
| } | |
| } | |
| return result; | |
| }, | |
| // function for parsing AOS keyframe formats | |
| flattenJSON: function( jsonKeys, times, values, valuePropertyName ) { | |
| var i = 1, key = jsonKeys[ 0 ]; | |
| while ( key !== undefined && key[ valuePropertyName ] === undefined ) { | |
| key = jsonKeys[ i ++ ]; | |
| } | |
| if ( key === undefined ) return; // no data | |
| var value = key[ valuePropertyName ]; | |
| if ( value === undefined ) return; // no data | |
| if ( Array.isArray( value ) ) { | |
| do { | |
| value = key[ valuePropertyName ]; | |
| if ( value !== undefined ) { | |
| times.push( key.time ); | |
| values.push.apply( values, value ); // push all elements | |
| } | |
| key = jsonKeys[ i ++ ]; | |
| } while ( key !== undefined ); | |
| } else if ( value.toArray !== undefined ) { | |
| // ...assume THREE.Math-ish | |
| do { | |
| value = key[ valuePropertyName ]; | |
| if ( value !== undefined ) { | |
| times.push( key.time ); | |
| value.toArray( values, values.length ); | |
| } | |
| key = jsonKeys[ i ++ ]; | |
| } while ( key !== undefined ); | |
| } else { | |
| // otherwise push as-is | |
| do { | |
| value = key[ valuePropertyName ]; | |
| if ( value !== undefined ) { | |
| times.push( key.time ); | |
| values.push( value ); | |
| } | |
| key = jsonKeys[ i ++ ]; | |
| } while ( key !== undefined ); | |
| } | |
| } | |
| }; | |
| // File:src/animation/KeyframeTrack.js | |
| /** | |
| * | |
| * A timed sequence of keyframes for a specific property. | |
| * | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.KeyframeTrack = function ( name, times, values, interpolation ) { | |
| if( name === undefined ) throw new Error( "track name is undefined" ); | |
| if( times === undefined || times.length === 0 ) { | |
| throw new Error( "no keyframes in track named " + name ); | |
| } | |
| this.name = name; | |
| this.times = THREE.AnimationUtils.convertArray( times, this.TimeBufferType ); | |
| this.values = THREE.AnimationUtils.convertArray( values, this.ValueBufferType ); | |
| this.setInterpolation( interpolation || this.DefaultInterpolation ); | |
| this.validate(); | |
| this.optimize(); | |
| }; | |
| THREE.KeyframeTrack.prototype = { | |
| constructor: THREE.KeyframeTrack, | |
| TimeBufferType: Float32Array, | |
| ValueBufferType: Float32Array, | |
| DefaultInterpolation: THREE.InterpolateLinear, | |
| InterpolantFactoryMethodDiscrete: function( result ) { | |
| return new THREE.DiscreteInterpolant( | |
| this.times, this.values, this.getValueSize(), result ); | |
| }, | |
| InterpolantFactoryMethodLinear: function( result ) { | |
| return new THREE.LinearInterpolant( | |
| this.times, this.values, this.getValueSize(), result ); | |
| }, | |
| InterpolantFactoryMethodSmooth: function( result ) { | |
| return new THREE.CubicInterpolant( | |
| this.times, this.values, this.getValueSize(), result ); | |
| }, | |
| setInterpolation: function( interpolation ) { | |
| var factoryMethod = undefined; | |
| switch ( interpolation ) { | |
| case THREE.InterpolateDiscrete: | |
| factoryMethod = this.InterpolantFactoryMethodDiscrete; | |
| break; | |
| case THREE.InterpolateLinear: | |
| factoryMethod = this.InterpolantFactoryMethodLinear; | |
| break; | |
| case THREE.InterpolateSmooth: | |
| factoryMethod = this.InterpolantFactoryMethodSmooth; | |
| break; | |
| } | |
| if ( factoryMethod === undefined ) { | |
| var message = "unsupported interpolation for " + | |
| this.ValueTypeName + " keyframe track named " + this.name; | |
| if ( this.createInterpolant === undefined ) { | |
| // fall back to default, unless the default itself is messed up | |
| if ( interpolation !== this.DefaultInterpolation ) { | |
| this.setInterpolation( this.DefaultInterpolation ); | |
| } else { | |
| throw new Error( message ); // fatal, in this case | |
| } | |
| } | |
| console.warn( message ); | |
| return; | |
| } | |
| this.createInterpolant = factoryMethod; | |
| }, | |
| getInterpolation: function() { | |
| switch ( this.createInterpolant ) { | |
| case this.InterpolantFactoryMethodDiscrete: | |
| return THREE.InterpolateDiscrete; | |
| case this.InterpolantFactoryMethodLinear: | |
| return THREE.InterpolateLinear; | |
| case this.InterpolantFactoryMethodSmooth: | |
| return THREE.InterpolateSmooth; | |
| } | |
| }, | |
| getValueSize: function() { | |
| return this.values.length / this.times.length; | |
| }, | |
| // move all keyframes either forwards or backwards in time | |
| shift: function( timeOffset ) { | |
| if( timeOffset !== 0.0 ) { | |
| var times = this.times; | |
| for( var i = 0, n = times.length; i !== n; ++ i ) { | |
| times[ i ] += timeOffset; | |
| } | |
| } | |
| return this; | |
| }, | |
| // scale all keyframe times by a factor (useful for frame <-> seconds conversions) | |
| scale: function( timeScale ) { | |
| if( timeScale !== 1.0 ) { | |
| var times = this.times; | |
| for( var i = 0, n = times.length; i !== n; ++ i ) { | |
| times[ i ] *= timeScale; | |
| } | |
| } | |
| return this; | |
| }, | |
| // removes keyframes before and after animation without changing any values within the range [startTime, endTime]. | |
| // IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values | |
| trim: function( startTime, endTime ) { | |
| var times = this.times, | |
| nKeys = times.length, | |
| from = 0, | |
| to = nKeys - 1; | |
| while ( from !== nKeys && times[ from ] < startTime ) ++ from; | |
| while ( to !== -1 && times[ to ] > endTime ) -- to; | |
| ++ to; // inclusive -> exclusive bound | |
| if( from !== 0 || to !== nKeys ) { | |
| // empty tracks are forbidden, so keep at least one keyframe | |
| if ( from >= to ) to = Math.max( to , 1 ), from = to - 1; | |
| var stride = this.getValueSize(); | |
| this.times = THREE.AnimationUtils.arraySlice( times, from, to ); | |
| this.values = THREE.AnimationUtils. | |
| arraySlice( this.values, from * stride, to * stride ); | |
| } | |
| return this; | |
| }, | |
| // ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable | |
| validate: function() { | |
| var valid = true; | |
| var valueSize = this.getValueSize(); | |
| if ( valueSize - Math.floor( valueSize ) !== 0 ) { | |
| console.error( "invalid value size in track", this ); | |
| valid = false; | |
| } | |
| var times = this.times, | |
| values = this.values, | |
| nKeys = times.length; | |
| if( nKeys === 0 ) { | |
| console.error( "track is empty", this ); | |
| valid = false; | |
| } | |
| var prevTime = null; | |
| for( var i = 0; i !== nKeys; i ++ ) { | |
| var currTime = times[ i ]; | |
| if ( typeof currTime === 'number' && isNaN( currTime ) ) { | |
| console.error( "time is not a valid number", this, i, currTime ); | |
| valid = false; | |
| break; | |
| } | |
| if( prevTime !== null && prevTime > currTime ) { | |
| console.error( "out of order keys", this, i, currTime, prevTime ); | |
| valid = false; | |
| break; | |
| } | |
| prevTime = currTime; | |
| } | |
| if ( values !== undefined ) { | |
| if ( THREE.AnimationUtils.isTypedArray( values ) ) { | |
| for ( var i = 0, n = values.length; i !== n; ++ i ) { | |
| var value = values[ i ]; | |
| if ( isNaN( value ) ) { | |
| console.error( "value is not a valid number", this, i, value ); | |
| valid = false; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| return valid; | |
| }, | |
| // removes equivalent sequential keys as common in morph target sequences | |
| // (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0) | |
| optimize: function() { | |
| var times = this.times, | |
| values = this.values, | |
| stride = this.getValueSize(), | |
| writeIndex = 1; | |
| for( var i = 1, n = times.length - 1; i <= n; ++ i ) { | |
| var keep = false; | |
| var time = times[ i ]; | |
| var timeNext = times[ i + 1 ]; | |
| // remove adjacent keyframes scheduled at the same time | |
| if ( time !== timeNext && ( i !== 1 || time !== time[ 0 ] ) ) { | |
| // remove unnecessary keyframes same as their neighbors | |
| var offset = i * stride, | |
| offsetP = offset - stride, | |
| offsetN = offset + stride; | |
| for ( var j = 0; j !== stride; ++ j ) { | |
| var value = values[ offset + j ]; | |
| if ( value !== values[ offsetP + j ] || | |
| value !== values[ offsetN + j ] ) { | |
| keep = true; | |
| break; | |
| } | |
| } | |
| } | |
| // in-place compaction | |
| if ( keep ) { | |
| if ( i !== writeIndex ) { | |
| times[ writeIndex ] = times[ i ]; | |
| var readOffset = i * stride, | |
| writeOffset = writeIndex * stride; | |
| for ( var j = 0; j !== stride; ++ j ) { | |
| values[ writeOffset + j ] = values[ readOffset + j ]; | |
| } | |
| } | |
| ++ writeIndex; | |
| } | |
| } | |
| if ( writeIndex !== times.length ) { | |
| this.times = THREE.AnimationUtils.arraySlice( times, 0, writeIndex ); | |
| this.values = THREE.AnimationUtils.arraySlice( values, 0, writeIndex * stride ); | |
| } | |
| return this; | |
| } | |
| }; | |
| // Static methods: | |
| Object.assign( THREE.KeyframeTrack, { | |
| // Serialization (in static context, because of constructor invocation | |
| // and automatic invocation of .toJSON): | |
| parse: function( json ) { | |
| if( json.type === undefined ) { | |
| throw new Error( "track type undefined, can not parse" ); | |
| } | |
| var trackType = THREE.KeyframeTrack._getTrackTypeForValueTypeName( json.type ); | |
| if ( json.times === undefined ) { | |
| console.warn( "legacy JSON format detected, converting" ); | |
| var times = [], values = []; | |
| THREE.AnimationUtils.flattenJSON( json.keys, times, values, 'value' ); | |
| json.times = times; | |
| json.values = values; | |
| } | |
| // derived classes can define a static parse method | |
| if ( trackType.parse !== undefined ) { | |
| return trackType.parse( json ); | |
| } else { | |
| // by default, we asssume a constructor compatible with the base | |
| return new trackType( | |
| json.name, json.times, json.values, json.interpolation ); | |
| } | |
| }, | |
| toJSON: function( track ) { | |
| var trackType = track.constructor; | |
| var json; | |
| // derived classes can define a static toJSON method | |
| if ( trackType.toJSON !== undefined ) { | |
| json = trackType.toJSON( track ); | |
| } else { | |
| // by default, we assume the data can be serialized as-is | |
| json = { | |
| 'name': track.name, | |
| 'times': THREE.AnimationUtils.convertArray( track.times, Array ), | |
| 'values': THREE.AnimationUtils.convertArray( track.values, Array ) | |
| }; | |
| var interpolation = track.getInterpolation(); | |
| if ( interpolation !== track.DefaultInterpolation ) { | |
| json.interpolation = interpolation; | |
| } | |
| } | |
| json.type = track.ValueTypeName; // mandatory | |
| return json; | |
| }, | |
| _getTrackTypeForValueTypeName: function( typeName ) { | |
| switch( typeName.toLowerCase() ) { | |
| case "scalar": | |
| case "double": | |
| case "float": | |
| case "number": | |
| case "integer": | |
| return THREE.NumberKeyframeTrack; | |
| case "vector": | |
| case "vector2": | |
| case "vector3": | |
| case "vector4": | |
| return THREE.VectorKeyframeTrack; | |
| case "color": | |
| return THREE.ColorKeyframeTrack; | |
| case "quaternion": | |
| return THREE.QuaternionKeyframeTrack; | |
| case "bool": | |
| case "boolean": | |
| return THREE.BooleanKeyframeTrack; | |
| case "string": | |
| return THREE.StringKeyframeTrack; | |
| }; | |
| throw new Error( "Unsupported typeName: " + typeName ); | |
| } | |
| } ); | |
| // File:src/animation/PropertyBinding.js | |
| /** | |
| * | |
| * A reference to a real property in the scene graph. | |
| * | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.PropertyBinding = function ( rootNode, path, parsedPath ) { | |
| this.path = path; | |
| this.parsedPath = parsedPath || | |
| THREE.PropertyBinding.parseTrackName( path ); | |
| this.node = THREE.PropertyBinding.findNode( | |
| rootNode, this.parsedPath.nodeName ) || rootNode; | |
| this.rootNode = rootNode; | |
| }; | |
| THREE.PropertyBinding.prototype = { | |
| constructor: THREE.PropertyBinding, | |
| getValue: function getValue_unbound( targetArray, offset ) { | |
| this.bind(); | |
| this.getValue( targetArray, offset ); | |
| // Note: This class uses a State pattern on a per-method basis: | |
| // 'bind' sets 'this.getValue' / 'setValue' and shadows the | |
| // prototype version of these methods with one that represents | |
| // the bound state. When the property is not found, the methods | |
| // become no-ops. | |
| }, | |
| setValue: function getValue_unbound( sourceArray, offset ) { | |
| this.bind(); | |
| this.setValue( sourceArray, offset ); | |
| }, | |
| // create getter / setter pair for a property in the scene graph | |
| bind: function() { | |
| var targetObject = this.node, | |
| parsedPath = this.parsedPath, | |
| objectName = parsedPath.objectName, | |
| propertyName = parsedPath.propertyName, | |
| propertyIndex = parsedPath.propertyIndex; | |
| if ( ! targetObject ) { | |
| targetObject = THREE.PropertyBinding.findNode( | |
| this.rootNode, parsedPath.nodeName ) || this.rootNode; | |
| this.node = targetObject; | |
| } | |
| // set fail state so we can just 'return' on error | |
| this.getValue = this._getValue_unavailable; | |
| this.setValue = this._setValue_unavailable; | |
| // ensure there is a value node | |
| if ( ! targetObject ) { | |
| console.error( " trying to update node for track: " + this.path + " but it wasn't found." ); | |
| return; | |
| } | |
| if( objectName ) { | |
| var objectIndex = parsedPath.objectIndex; | |
| // special cases were we need to reach deeper into the hierarchy to get the face materials.... | |
| switch ( objectName ) { | |
| case 'materials': | |
| if( ! targetObject.material ) { | |
| console.error( ' can not bind to material as node does not have a material', this ); | |
| return; | |
| } | |
| if( ! targetObject.material.materials ) { | |
| console.error( ' can not bind to material.materials as node.material does not have a materials array', this ); | |
| return; | |
| } | |
| targetObject = targetObject.material.materials; | |
| break; | |
| case 'bones': | |
| if( ! targetObject.skeleton ) { | |
| console.error( ' can not bind to bones as node does not have a skeleton', this ); | |
| return; | |
| } | |
| // potential future optimization: skip this if propertyIndex is already an integer | |
| // and convert the integer string to a true integer. | |
| targetObject = targetObject.skeleton.bones; | |
| // support resolving morphTarget names into indices. | |
| for ( var i = 0; i < targetObject.length; i ++ ) { | |
| if ( targetObject[i].name === objectIndex ) { | |
| objectIndex = i; | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| if ( targetObject[ objectName ] === undefined ) { | |
| console.error( ' can not bind to objectName of node, undefined', this ); | |
| return; | |
| } | |
| targetObject = targetObject[ objectName ]; | |
| } | |
| if ( objectIndex !== undefined ) { | |
| if( targetObject[ objectIndex ] === undefined ) { | |
| console.error( " trying to bind to objectIndex of objectName, but is undefined:", this, targetObject ); | |
| return; | |
| } | |
| targetObject = targetObject[ objectIndex ]; | |
| } | |
| } | |
| // resolve property | |
| var nodeProperty = targetObject[ propertyName ]; | |
| if ( ! nodeProperty ) { | |
| var nodeName = parsedPath.nodeName; | |
| console.error( " trying to update property for track: " + nodeName + | |
| '.' + propertyName + " but it wasn't found.", targetObject ); | |
| return; | |
| } | |
| // determine versioning scheme | |
| var versioning = this.Versioning.None; | |
| if ( targetObject.needsUpdate !== undefined ) { // material | |
| versioning = this.Versioning.NeedsUpdate; | |
| this.targetObject = targetObject; | |
| } else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform | |
| versioning = this.Versioning.MatrixWorldNeedsUpdate; | |
| this.targetObject = targetObject; | |
| } | |
| // determine how the property gets bound | |
| var bindingType = this.BindingType.Direct; | |
| if ( propertyIndex !== undefined ) { | |
| // access a sub element of the property array (only primitives are supported right now) | |
| if ( propertyName === "morphTargetInfluences" ) { | |
| // potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer. | |
| // support resolving morphTarget names into indices. | |
| if ( ! targetObject.geometry ) { | |
| console.error( ' can not bind to morphTargetInfluences becasuse node does not have a geometry', this ); | |
| return; | |
| } | |
| if ( ! targetObject.geometry.morphTargets ) { | |
| console.error( ' can not bind to morphTargetInfluences becasuse node does not have a geometry.morphTargets', this ); | |
| return; | |
| } | |
| for ( var i = 0; i < this.node.geometry.morphTargets.length; i ++ ) { | |
| if ( targetObject.geometry.morphTargets[i].name === propertyIndex ) { | |
| propertyIndex = i; | |
| break; | |
| } | |
| } | |
| } | |
| bindingType = this.BindingType.ArrayElement; | |
| this.resolvedProperty = nodeProperty; | |
| this.propertyIndex = propertyIndex; | |
| } else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) { | |
| // must use copy for Object3D.Euler/Quaternion | |
| bindingType = this.BindingType.HasFromToArray; | |
| this.resolvedProperty = nodeProperty; | |
| } else if ( nodeProperty.length !== undefined ) { | |
| bindingType = this.BindingType.EntireArray; | |
| this.resolvedProperty = nodeProperty; | |
| } else { | |
| this.propertyName = propertyName; | |
| } | |
| // select getter / setter | |
| this.getValue = this.GetterByBindingType[ bindingType ]; | |
| this.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ]; | |
| }, | |
| unbind: function() { | |
| this.node = null; | |
| // back to the prototype version of getValue / setValue | |
| // note: avoiding to mutate the shape of 'this' via 'delete' | |
| this.getValue = this._getValue_unbound; | |
| this.setValue = this._setValue_unbound; | |
| } | |
| }; | |
| Object.assign( THREE.PropertyBinding.prototype, { // prototype, continued | |
| // these are used to "bind" a nonexistent property | |
| _getValue_unavailable: function() {}, | |
| _setValue_unavailable: function() {}, | |
| // initial state of these methods that calls 'bind' | |
| _getValue_unbound: THREE.PropertyBinding.prototype.getValue, | |
| _setValue_unbound: THREE.PropertyBinding.prototype.setValue, | |
| BindingType: { | |
| Direct: 0, | |
| EntireArray: 1, | |
| ArrayElement: 2, | |
| HasFromToArray: 3 | |
| }, | |
| Versioning: { | |
| None: 0, | |
| NeedsUpdate: 1, | |
| MatrixWorldNeedsUpdate: 2 | |
| }, | |
| GetterByBindingType: [ | |
| function getValue_direct( buffer, offset ) { | |
| buffer[ offset ] = this.node[ this.propertyName ]; | |
| }, | |
| function getValue_array( buffer, offset ) { | |
| var source = this.resolvedProperty; | |
| for ( var i = 0, n = source.length; i !== n; ++ i ) { | |
| buffer[ offset ++ ] = source[ i ]; | |
| } | |
| }, | |
| function getValue_arrayElement( buffer, offset ) { | |
| buffer[ offset ] = this.resolvedProperty[ this.propertyIndex ]; | |
| }, | |
| function getValue_toArray( buffer, offset ) { | |
| this.resolvedProperty.toArray( buffer, offset ); | |
| } | |
| ], | |
| SetterByBindingTypeAndVersioning: [ | |
| [ | |
| // Direct | |
| function setValue_direct( buffer, offset ) { | |
| this.node[ this.propertyName ] = buffer[ offset ]; | |
| }, | |
| function setValue_direct_setNeedsUpdate( buffer, offset ) { | |
| this.node[ this.propertyName ] = buffer[ offset ]; | |
| this.targetObject.needsUpdate = true; | |
| }, | |
| function setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) { | |
| this.node[ this.propertyName ] = buffer[ offset ]; | |
| this.targetObject.matrixWorldNeedsUpdate = true; | |
| } | |
| ], [ | |
| // EntireArray | |
| function setValue_array( buffer, offset ) { | |
| var dest = this.resolvedProperty; | |
| for ( var i = 0, n = dest.length; i !== n; ++ i ) { | |
| dest[ i ] = buffer[ offset ++ ]; | |
| } | |
| }, | |
| function setValue_array_setNeedsUpdate( buffer, offset ) { | |
| var dest = this.resolvedProperty; | |
| for ( var i = 0, n = dest.length; i !== n; ++ i ) { | |
| dest[ i ] = buffer[ offset ++ ]; | |
| } | |
| this.targetObject.needsUpdate = true; | |
| }, | |
| function setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) { | |
| var dest = this.resolvedProperty; | |
| for ( var i = 0, n = dest.length; i !== n; ++ i ) { | |
| dest[ i ] = buffer[ offset ++ ]; | |
| } | |
| this.targetObject.matrixWorldNeedsUpdate = true; | |
| } | |
| ], [ | |
| // ArrayElement | |
| function setValue_arrayElement( buffer, offset ) { | |
| this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ]; | |
| }, | |
| function setValue_arrayElement_setNeedsUpdate( buffer, offset ) { | |
| this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ]; | |
| this.targetObject.needsUpdate = true; | |
| }, | |
| function setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) { | |
| this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ]; | |
| this.targetObject.matrixWorldNeedsUpdate = true; | |
| } | |
| ], [ | |
| // HasToFromArray | |
| function setValue_fromArray( buffer, offset ) { | |
| this.resolvedProperty.fromArray( buffer, offset ); | |
| }, | |
| function setValue_fromArray_setNeedsUpdate( buffer, offset ) { | |
| this.resolvedProperty.fromArray( buffer, offset ); | |
| this.targetObject.needsUpdate = true; | |
| }, | |
| function setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) { | |
| this.resolvedProperty.fromArray( buffer, offset ); | |
| this.targetObject.matrixWorldNeedsUpdate = true; | |
| } | |
| ] | |
| ] | |
| } ); | |
| THREE.PropertyBinding.Composite = | |
| function( targetGroup, path, optionalParsedPath ) { | |
| var parsedPath = optionalParsedPath || | |
| THREE.PropertyBinding.parseTrackName( path ); | |
| this._targetGroup = targetGroup; | |
| this._bindings = targetGroup.subscribe_( path, parsedPath ); | |
| }; | |
| THREE.PropertyBinding.Composite.prototype = { | |
| constructor: THREE.PropertyBinding.Composite, | |
| getValue: function( array, offset ) { | |
| this.bind(); // bind all binding | |
| var firstValidIndex = this._targetGroup.nCachedObjects_, | |
| binding = this._bindings[ firstValidIndex ]; | |
| // and only call .getValue on the first | |
| if ( binding !== undefined ) binding.getValue( array, offset ); | |
| }, | |
| setValue: function( array, offset ) { | |
| var bindings = this._bindings; | |
| for ( var i = this._targetGroup.nCachedObjects_, | |
| n = bindings.length; i !== n; ++ i ) { | |
| bindings[ i ].setValue( array, offset ); | |
| } | |
| }, | |
| bind: function() { | |
| var bindings = this._bindings; | |
| for ( var i = this._targetGroup.nCachedObjects_, | |
| n = bindings.length; i !== n; ++ i ) { | |
| bindings[ i ].bind(); | |
| } | |
| }, | |
| unbind: function() { | |
| var bindings = this._bindings; | |
| for ( var i = this._targetGroup.nCachedObjects_, | |
| n = bindings.length; i !== n; ++ i ) { | |
| bindings[ i ].unbind(); | |
| } | |
| } | |
| }; | |
| THREE.PropertyBinding.create = function( root, path, parsedPath ) { | |
| if ( ! ( root instanceof THREE.AnimationObjectGroup ) ) { | |
| return new THREE.PropertyBinding( root, path, parsedPath ); | |
| } else { | |
| return new THREE.PropertyBinding.Composite( root, path, parsedPath ); | |
| } | |
| }; | |
| THREE.PropertyBinding.parseTrackName = function( trackName ) { | |
| // matches strings in the form of: | |
| // nodeName.property | |
| // nodeName.property[accessor] | |
| // nodeName.material.property[accessor] | |
| // uuid.property[accessor] | |
| // uuid.objectName[objectIndex].propertyName[propertyIndex] | |
| // parentName/nodeName.property | |
| // parentName/parentName/nodeName.property[index] | |
| // .bone[Armature.DEF_cog].position | |
| // created and tested via https://regex101.com/#javascript | |
| var re = /^(([\w]+\/)*)([\w-\d]+)?(\.([\w]+)(\[([\w\d\[\]\_. ]+)\])?)?(\.([\w.]+)(\[([\w\d\[\]\_. ]+)\])?)$/; | |
| var matches = re.exec(trackName); | |
| if( ! matches ) { | |
| throw new Error( "cannot parse trackName at all: " + trackName ); | |
| } | |
| if (matches.index === re.lastIndex) { | |
| re.lastIndex++; | |
| } | |
| var results = { | |
| // directoryName: matches[1], // (tschw) currently unused | |
| nodeName: matches[3], // allowed to be null, specified root node. | |
| objectName: matches[5], | |
| objectIndex: matches[7], | |
| propertyName: matches[9], | |
| propertyIndex: matches[11] // allowed to be null, specifies that the whole property is set. | |
| }; | |
| if( results.propertyName === null || results.propertyName.length === 0 ) { | |
| throw new Error( "can not parse propertyName from trackName: " + trackName ); | |
| } | |
| return results; | |
| }; | |
| THREE.PropertyBinding.findNode = function( root, nodeName ) { | |
| if( ! nodeName || nodeName === "" || nodeName === "root" || nodeName === "." || nodeName === -1 || nodeName === root.name || nodeName === root.uuid ) { | |
| return root; | |
| } | |
| // search into skeleton bones. | |
| if( root.skeleton ) { | |
| var searchSkeleton = function( skeleton ) { | |
| for( var i = 0; i < skeleton.bones.length; i ++ ) { | |
| var bone = skeleton.bones[i]; | |
| if( bone.name === nodeName ) { | |
| return bone; | |
| } | |
| } | |
| return null; | |
| }; | |
| var bone = searchSkeleton( root.skeleton ); | |
| if( bone ) { | |
| return bone; | |
| } | |
| } | |
| // search into node subtree. | |
| if( root.children ) { | |
| var searchNodeSubtree = function( children ) { | |
| for( var i = 0; i < children.length; i ++ ) { | |
| var childNode = children[i]; | |
| if( childNode.name === nodeName || childNode.uuid === nodeName ) { | |
| return childNode; | |
| } | |
| var result = searchNodeSubtree( childNode.children ); | |
| if( result ) return result; | |
| } | |
| return null; | |
| }; | |
| var subTreeNode = searchNodeSubtree( root.children ); | |
| if( subTreeNode ) { | |
| return subTreeNode; | |
| } | |
| } | |
| return null; | |
| } | |
| // File:src/animation/PropertyMixer.js | |
| /** | |
| * | |
| * Buffered scene graph property that allows weighted accumulation. | |
| * | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.PropertyMixer = function ( binding, typeName, valueSize ) { | |
| this.binding = binding; | |
| this.valueSize = valueSize; | |
| var bufferType = Float64Array, | |
| mixFunction; | |
| switch ( typeName ) { | |
| case 'quaternion': mixFunction = this._slerp; break; | |
| case 'string': | |
| case 'bool': | |
| bufferType = Array, mixFunction = this._select; break; | |
| default: mixFunction = this._lerp; | |
| } | |
| this.buffer = new bufferType( valueSize * 4 ); | |
| // layout: [ incoming | accu0 | accu1 | orig ] | |
| // | |
| // interpolators can use .buffer as their .result | |
| // the data then goes to 'incoming' | |
| // | |
| // 'accu0' and 'accu1' are used frame-interleaved for | |
| // the cumulative result and are compared to detect | |
| // changes | |
| // | |
| // 'orig' stores the original state of the property | |
| this._mixBufferRegion = mixFunction; | |
| this.cumulativeWeight = 0; | |
| this.useCount = 0; | |
| this.referenceCount = 0; | |
| }; | |
| THREE.PropertyMixer.prototype = { | |
| constructor: THREE.PropertyMixer, | |
| // accumulate data in the 'incoming' region into 'accu<i>' | |
| accumulate: function( accuIndex, weight ) { | |
| // note: happily accumulating nothing when weight = 0, the caller knows | |
| // the weight and shouldn't have made the call in the first place | |
| var buffer = this.buffer, | |
| stride = this.valueSize, | |
| offset = accuIndex * stride + stride, | |
| currentWeight = this.cumulativeWeight; | |
| if ( currentWeight === 0 ) { | |
| // accuN := incoming * weight | |
| for ( var i = 0; i !== stride; ++ i ) { | |
| buffer[ offset + i ] = buffer[ i ]; | |
| } | |
| currentWeight = weight; | |
| } else { | |
| // accuN := accuN + incoming * weight | |
| currentWeight += weight; | |
| var mix = weight / currentWeight; | |
| this._mixBufferRegion( buffer, offset, 0, mix, stride ); | |
| } | |
| this.cumulativeWeight = currentWeight; | |
| }, | |
| // apply the state of 'accu<i>' to the binding when accus differ | |
| apply: function( accuIndex ) { | |
| var stride = this.valueSize, | |
| buffer = this.buffer, | |
| offset = accuIndex * stride + stride, | |
| weight = this.cumulativeWeight, | |
| binding = this.binding; | |
| this.cumulativeWeight = 0; | |
| if ( weight < 1 ) { | |
| // accuN := accuN + original * ( 1 - cumulativeWeight ) | |
| var originalValueOffset = stride * 3; | |
| this._mixBufferRegion( | |
| buffer, offset, originalValueOffset, 1 - weight, stride ); | |
| } | |
| for ( var i = stride, e = stride + stride; i !== e; ++ i ) { | |
| if ( buffer[ i ] !== buffer[ i + stride ] ) { | |
| // value has changed -> update scene graph | |
| binding.setValue( buffer, offset ); | |
| break; | |
| } | |
| } | |
| }, | |
| // remember the state of the bound property and copy it to both accus | |
| saveOriginalState: function() { | |
| var binding = this.binding; | |
| var buffer = this.buffer, | |
| stride = this.valueSize, | |
| originalValueOffset = stride * 3; | |
| binding.getValue( buffer, originalValueOffset ); | |
| // accu[0..1] := orig -- initially detect changes against the original | |
| for ( var i = stride, e = originalValueOffset; i !== e; ++ i ) { | |
| buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ]; | |
| } | |
| this.cumulativeWeight = 0; | |
| }, | |
| // apply the state previously taken via 'saveOriginalState' to the binding | |
| restoreOriginalState: function() { | |
| var originalValueOffset = this.valueSize * 3; | |
| this.binding.setValue( this.buffer, originalValueOffset ); | |
| }, | |
| // mix functions | |
| _select: function( buffer, dstOffset, srcOffset, t, stride ) { | |
| if ( t >= 0.5 ) { | |
| for ( var i = 0; i !== stride; ++ i ) { | |
| buffer[ dstOffset + i ] = buffer[ srcOffset + i ]; | |
| } | |
| } | |
| }, | |
| _slerp: function( buffer, dstOffset, srcOffset, t, stride ) { | |
| THREE.Quaternion.slerpFlat( buffer, dstOffset, | |
| buffer, dstOffset, buffer, srcOffset, t ); | |
| }, | |
| _lerp: function( buffer, dstOffset, srcOffset, t, stride ) { | |
| var s = 1 - t; | |
| for ( var i = 0; i !== stride; ++ i ) { | |
| var j = dstOffset + i; | |
| buffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t; | |
| } | |
| } | |
| }; | |
| // File:src/animation/tracks/BooleanKeyframeTrack.js | |
| /** | |
| * | |
| * A Track of Boolean keyframe values. | |
| * | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.BooleanKeyframeTrack = function ( name, times, values ) { | |
| THREE.KeyframeTrack.call( this, name, times, values ); | |
| }; | |
| THREE.BooleanKeyframeTrack.prototype = | |
| Object.assign( Object.create( THREE.KeyframeTrack.prototype ), { | |
| constructor: THREE.BooleanKeyframeTrack, | |
| ValueTypeName: 'bool', | |
| ValueBufferType: Array, | |
| DefaultInterpolation: THREE.IntepolateDiscrete, | |
| InterpolantFactoryMethodLinear: undefined, | |
| InterpolantFactoryMethodSmooth: undefined | |
| // Note: Actually this track could have a optimized / compressed | |
| // representation of a single value and a custom interpolant that | |
| // computes "firstValue ^ isOdd( index )". | |
| } ); | |
| // File:src/animation/tracks/NumberKeyframeTrack.js | |
| /** | |
| * | |
| * A Track of numeric keyframe values. | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.NumberKeyframeTrack = function ( name, times, values, interpolation ) { | |
| THREE.KeyframeTrack.call( this, name, times, values, interpolation ); | |
| }; | |
| THREE.NumberKeyframeTrack.prototype = | |
| Object.assign( Object.create( THREE.KeyframeTrack.prototype ), { | |
| constructor: THREE.NumberKeyframeTrack, | |
| ValueTypeName: 'number', | |
| // ValueBufferType is inherited | |
| // DefaultInterpolation is inherited | |
| } ); | |
| // File:src/animation/tracks/QuaternionKeyframeTrack.js | |
| /** | |
| * | |
| * A Track of quaternion keyframe values. | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.QuaternionKeyframeTrack = function ( name, times, values, interpolation ) { | |
| THREE.KeyframeTrack.call( this, name, times, values, interpolation ); | |
| }; | |
| THREE.QuaternionKeyframeTrack.prototype = | |
| Object.assign( Object.create( THREE.KeyframeTrack.prototype ), { | |
| constructor: THREE.QuaternionKeyframeTrack, | |
| ValueTypeName: 'quaternion', | |
| // ValueBufferType is inherited | |
| DefaultInterpolation: THREE.InterpolateLinear, | |
| InterpolantFactoryMethodLinear: function( result ) { | |
| return new THREE.QuaternionLinearInterpolant( | |
| this.times, this.values, this.getValueSize(), result ); | |
| }, | |
| InterpolantFactoryMethodSmooth: undefined // not yet implemented | |
| } ); | |
| // File:src/animation/tracks/StringKeyframeTrack.js | |
| /** | |
| * | |
| * A Track that interpolates Strings | |
| * | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.StringKeyframeTrack = function ( name, times, values, interpolation ) { | |
| THREE.KeyframeTrack.call( this, name, times, values, interpolation ); | |
| }; | |
| THREE.StringKeyframeTrack.prototype = | |
| Object.assign( Object.create( THREE.KeyframeTrack.prototype ), { | |
| constructor: THREE.StringKeyframeTrack, | |
| ValueTypeName: 'string', | |
| ValueBufferType: Array, | |
| DefaultInterpolation: THREE.IntepolateDiscrete, | |
| InterpolantFactoryMethodLinear: undefined, | |
| InterpolantFactoryMethodSmooth: undefined | |
| } ); | |
| // File:src/animation/tracks/VectorKeyframeTrack.js | |
| /** | |
| * | |
| * A Track of vectored keyframe values. | |
| * | |
| * | |
| * @author Ben Houston / http://clara.io/ | |
| * @author David Sarno / http://lighthaus.us/ | |
| * @author tschw | |
| */ | |
| THREE.VectorKeyframeTrack = function ( name, times, values, interpolation ) { | |
| THREE.KeyframeTrack.call( this, name, times, values, interpolation ); | |
| }; | |
| THREE.VectorKeyframeTrack.prototype = | |
| Object.assign( Object.create( THREE.KeyframeTrack.prototype ), { | |
| constructor: THREE.VectorKeyframeTrack, | |
| ValueTypeName: 'vector' | |
| // ValueBufferType is inherited | |
| // DefaultInterpolation is inherited | |
| } ); | |
| // File:src/audio/Audio.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Audio = function ( listener ) { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Audio'; | |
| this.context = listener.context; | |
| this.source = this.context.createBufferSource(); | |
| this.source.onended = this.onEnded.bind( this ); | |
| this.gain = this.context.createGain(); | |
| this.gain.connect( listener.getInput() ); | |
| this.autoplay = false; | |
| this.startTime = 0; | |
| this.playbackRate = 1; | |
| this.isPlaying = false; | |
| this.hasPlaybackControl = true; | |
| this.sourceType = 'empty'; | |
| this.filter = null; | |
| }; | |
| THREE.Audio.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Audio.prototype.constructor = THREE.Audio; | |
| THREE.Audio.prototype.getOutput = function () { | |
| return this.gain; | |
| }; | |
| THREE.Audio.prototype.load = function ( file ) { | |
| var buffer = new THREE.AudioBuffer( this.context ); | |
| buffer.load( file ); | |
| this.setBuffer( buffer ); | |
| return this; | |
| }; | |
| THREE.Audio.prototype.setNodeSource = function ( audioNode ) { | |
| this.hasPlaybackControl = false; | |
| this.sourceType = 'audioNode'; | |
| this.source = audioNode; | |
| this.connect(); | |
| return this; | |
| }; | |
| THREE.Audio.prototype.setBuffer = function ( audioBuffer ) { | |
| var scope = this; | |
| audioBuffer.onReady( function( buffer ) { | |
| scope.source.buffer = buffer; | |
| scope.sourceType = 'buffer'; | |
| if ( scope.autoplay ) scope.play(); | |
| } ); | |
| return this; | |
| }; | |
| THREE.Audio.prototype.play = function () { | |
| if ( this.isPlaying === true ) { | |
| console.warn( 'THREE.Audio: Audio is already playing.' ); | |
| return; | |
| } | |
| if ( this.hasPlaybackControl === false ) { | |
| console.warn( 'THREE.Audio: this Audio has no playback control.' ); | |
| return; | |
| } | |
| var source = this.context.createBufferSource(); | |
| source.buffer = this.source.buffer; | |
| source.loop = this.source.loop; | |
| source.onended = this.source.onended; | |
| source.start( 0, this.startTime ); | |
| source.playbackRate.value = this.playbackRate; | |
| this.isPlaying = true; | |
| this.source = source; | |
| this.connect(); | |
| }; | |
| THREE.Audio.prototype.pause = function () { | |
| if ( this.hasPlaybackControl === false ) { | |
| console.warn( 'THREE.Audio: this Audio has no playback control.' ); | |
| return; | |
| } | |
| this.source.stop(); | |
| this.startTime = this.context.currentTime; | |
| }; | |
| THREE.Audio.prototype.stop = function () { | |
| if ( this.hasPlaybackControl === false ) { | |
| console.warn( 'THREE.Audio: this Audio has no playback control.' ); | |
| return; | |
| } | |
| this.source.stop(); | |
| this.startTime = 0; | |
| }; | |
| THREE.Audio.prototype.connect = function () { | |
| if ( this.filter !== null ) { | |
| this.source.connect( this.filter ); | |
| this.filter.connect( this.getOutput() ); | |
| } else { | |
| this.source.connect( this.getOutput() ); | |
| } | |
| }; | |
| THREE.Audio.prototype.disconnect = function () { | |
| if ( this.filter !== null ) { | |
| this.source.disconnect( this.filter ); | |
| this.filter.disconnect( this.getOutput() ); | |
| } else { | |
| this.source.disconnect( this.getOutput() ); | |
| } | |
| }; | |
| THREE.Audio.prototype.getFilter = function () { | |
| return this.filter; | |
| }; | |
| THREE.Audio.prototype.setFilter = function ( value ) { | |
| if ( value === undefined ) value = null; | |
| if ( this.isPlaying === true ) { | |
| this.disconnect(); | |
| this.filter = value; | |
| this.connect(); | |
| } else { | |
| this.filter = value; | |
| } | |
| }; | |
| THREE.Audio.prototype.setPlaybackRate = function ( value ) { | |
| if ( this.hasPlaybackControl === false ) { | |
| console.warn( 'THREE.Audio: this Audio has no playback control.' ); | |
| return; | |
| } | |
| this.playbackRate = value; | |
| if ( this.isPlaying === true ) { | |
| this.source.playbackRate.value = this.playbackRate; | |
| } | |
| }; | |
| THREE.Audio.prototype.getPlaybackRate = function () { | |
| return this.playbackRate; | |
| }; | |
| THREE.Audio.prototype.onEnded = function() { | |
| this.isPlaying = false; | |
| }; | |
| THREE.Audio.prototype.setLoop = function ( value ) { | |
| if ( this.hasPlaybackControl === false ) { | |
| console.warn( 'THREE.Audio: this Audio has no playback control.' ); | |
| return; | |
| } | |
| this.source.loop = value; | |
| }; | |
| THREE.Audio.prototype.getLoop = function () { | |
| if ( this.hasPlaybackControl === false ) { | |
| console.warn( 'THREE.Audio: this Audio has no playback control.' ); | |
| return false; | |
| } | |
| return this.source.loop; | |
| }; | |
| THREE.Audio.prototype.setVolume = function ( value ) { | |
| this.gain.gain.value = value; | |
| }; | |
| THREE.Audio.prototype.getVolume = function () { | |
| return this.gain.gain.value; | |
| }; | |
| // File:src/audio/AudioAnalyser.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.AudioAnalyser = function ( audio, fftSize ) { | |
| this.analyser = audio.context.createAnalyser(); | |
| this.analyser.fftSize = fftSize !== undefined ? fftSize : 2048; | |
| this.data = new Uint8Array( this.analyser.frequencyBinCount ); | |
| audio.getOutput().connect( this.analyser ); | |
| }; | |
| THREE.AudioAnalyser.prototype = { | |
| constructor: THREE.AudioAnalyser, | |
| getData: function () { | |
| this.analyser.getByteFrequencyData( this.data ); | |
| return this.data; | |
| } | |
| }; | |
| // File:src/audio/AudioBuffer.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.AudioBuffer = function ( context ) { | |
| this.context = context; | |
| this.ready = false; | |
| this.readyCallbacks = []; | |
| }; | |
| THREE.AudioBuffer.prototype.load = function ( file ) { | |
| var scope = this; | |
| var request = new XMLHttpRequest(); | |
| request.open( 'GET', file, true ); | |
| request.responseType = 'arraybuffer'; | |
| request.onload = function ( e ) { | |
| scope.context.decodeAudioData( this.response, function ( buffer ) { | |
| scope.buffer = buffer; | |
| scope.ready = true; | |
| for ( var i = 0; i < scope.readyCallbacks.length; i ++ ) { | |
| scope.readyCallbacks[ i ]( scope.buffer ); | |
| } | |
| scope.readyCallbacks = []; | |
| } ); | |
| }; | |
| request.send(); | |
| return this; | |
| }; | |
| THREE.AudioBuffer.prototype.onReady = function ( callback ) { | |
| if ( this.ready ) { | |
| callback( this.buffer ); | |
| } else { | |
| this.readyCallbacks.push( callback ); | |
| } | |
| }; | |
| // File:src/audio/PositionalAudio.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.PositionalAudio = function ( listener ) { | |
| THREE.Audio.call( this, listener ); | |
| this.panner = this.context.createPanner(); | |
| this.panner.connect( this.gain ); | |
| }; | |
| THREE.PositionalAudio.prototype = Object.create( THREE.Audio.prototype ); | |
| THREE.PositionalAudio.prototype.constructor = THREE.PositionalAudio; | |
| THREE.PositionalAudio.prototype.getOutput = function () { | |
| return this.panner; | |
| }; | |
| THREE.PositionalAudio.prototype.setRefDistance = function ( value ) { | |
| this.panner.refDistance = value; | |
| }; | |
| THREE.PositionalAudio.prototype.getRefDistance = function () { | |
| return this.panner.refDistance; | |
| }; | |
| THREE.PositionalAudio.prototype.setRolloffFactor = function ( value ) { | |
| this.panner.rolloffFactor = value; | |
| }; | |
| THREE.PositionalAudio.prototype.getRolloffFactor = function () { | |
| return this.panner.rolloffFactor; | |
| }; | |
| THREE.PositionalAudio.prototype.setDistanceModel = function ( value ) { | |
| this.panner.distanceModel = value; | |
| }; | |
| THREE.PositionalAudio.prototype.getDistanceModel = function () { | |
| return this.panner.distanceModel; | |
| }; | |
| THREE.PositionalAudio.prototype.setMaxDistance = function ( value ) { | |
| this.panner.maxDistance = value; | |
| }; | |
| THREE.PositionalAudio.prototype.getMaxDistance = function () { | |
| return this.panner.maxDistance; | |
| }; | |
| THREE.PositionalAudio.prototype.updateMatrixWorld = ( function () { | |
| var position = new THREE.Vector3(); | |
| return function updateMatrixWorld( force ) { | |
| THREE.Object3D.prototype.updateMatrixWorld.call( this, force ); | |
| position.setFromMatrixPosition( this.matrixWorld ); | |
| this.panner.setPosition( position.x, position.y, position.z ); | |
| }; | |
| } )(); | |
| // File:src/audio/AudioListener.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.AudioListener = function () { | |
| THREE.Object3D.call( this ); | |
| this.type = 'AudioListener'; | |
| this.context = new ( window.AudioContext || window.webkitAudioContext )(); | |
| this.gain = this.context.createGain(); | |
| this.gain.connect( this.context.destination ); | |
| this.filter = null; | |
| }; | |
| THREE.AudioListener.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.AudioListener.prototype.constructor = THREE.AudioListener; | |
| THREE.AudioListener.prototype.getInput = function () { | |
| return this.gain; | |
| }; | |
| THREE.AudioListener.prototype.removeFilter = function ( ) { | |
| if ( this.filter !== null ) { | |
| this.gain.disconnect( this.filter ); | |
| this.filter.disconnect( this.context.destination ); | |
| this.gain.connect( this.context.destination ); | |
| this.filter = null; | |
| } | |
| }; | |
| THREE.AudioListener.prototype.setFilter = function ( value ) { | |
| if ( this.filter !== null ) { | |
| this.gain.disconnect( this.filter ); | |
| this.filter.disconnect( this.context.destination ); | |
| } else { | |
| this.gain.disconnect( this.context.destination ); | |
| } | |
| this.filter = value; | |
| this.gain.connect( this.filter ); | |
| this.filter.connect( this.context.destination ); | |
| }; | |
| THREE.AudioListener.prototype.getFilter = function () { | |
| return this.filter; | |
| }; | |
| THREE.AudioListener.prototype.setMasterVolume = function ( value ) { | |
| this.gain.gain.value = value; | |
| }; | |
| THREE.AudioListener.prototype.getMasterVolume = function () { | |
| return this.gain.gain.value; | |
| }; | |
| THREE.AudioListener.prototype.updateMatrixWorld = ( function () { | |
| var position = new THREE.Vector3(); | |
| var quaternion = new THREE.Quaternion(); | |
| var scale = new THREE.Vector3(); | |
| var orientation = new THREE.Vector3(); | |
| return function updateMatrixWorld( force ) { | |
| THREE.Object3D.prototype.updateMatrixWorld.call( this, force ); | |
| var listener = this.context.listener; | |
| var up = this.up; | |
| this.matrixWorld.decompose( position, quaternion, scale ); | |
| orientation.set( 0, 0, - 1 ).applyQuaternion( quaternion ); | |
| listener.setPosition( position.x, position.y, position.z ); | |
| listener.setOrientation( orientation.x, orientation.y, orientation.z, up.x, up.y, up.z ); | |
| }; | |
| } )(); | |
| // File:src/cameras/Camera.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author WestLangley / http://github.com/WestLangley | |
| */ | |
| THREE.Camera = function () { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Camera'; | |
| this.matrixWorldInverse = new THREE.Matrix4(); | |
| this.projectionMatrix = new THREE.Matrix4(); | |
| }; | |
| THREE.Camera.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Camera.prototype.constructor = THREE.Camera; | |
| THREE.Camera.prototype.getWorldDirection = function () { | |
| var quaternion = new THREE.Quaternion(); | |
| return function ( optionalTarget ) { | |
| var result = optionalTarget || new THREE.Vector3(); | |
| this.getWorldQuaternion( quaternion ); | |
| return result.set( 0, 0, - 1 ).applyQuaternion( quaternion ); | |
| }; | |
| }(); | |
| THREE.Camera.prototype.lookAt = function () { | |
| // This routine does not support cameras with rotated and/or translated parent(s) | |
| var m1 = new THREE.Matrix4(); | |
| return function ( vector ) { | |
| m1.lookAt( this.position, vector, this.up ); | |
| this.quaternion.setFromRotationMatrix( m1 ); | |
| }; | |
| }(); | |
| THREE.Camera.prototype.clone = function () { | |
| return new this.constructor().copy( this ); | |
| }; | |
| THREE.Camera.prototype.copy = function ( source ) { | |
| THREE.Object3D.prototype.copy.call( this, source ); | |
| this.matrixWorldInverse.copy( source.matrixWorldInverse ); | |
| this.projectionMatrix.copy( source.projectionMatrix ); | |
| return this; | |
| }; | |
| // File:src/cameras/CubeCamera.js | |
| /** | |
| * Camera for rendering cube maps | |
| * - renders scene into axis-aligned cube | |
| * | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.CubeCamera = function ( near, far, cubeResolution ) { | |
| THREE.Object3D.call( this ); | |
| this.type = 'CubeCamera'; | |
| var fov = 90, aspect = 1; | |
| var cameraPX = new THREE.PerspectiveCamera( fov, aspect, near, far ); | |
| cameraPX.up.set( 0, - 1, 0 ); | |
| cameraPX.lookAt( new THREE.Vector3( 1, 0, 0 ) ); | |
| this.add( cameraPX ); | |
| var cameraNX = new THREE.PerspectiveCamera( fov, aspect, near, far ); | |
| cameraNX.up.set( 0, - 1, 0 ); | |
| cameraNX.lookAt( new THREE.Vector3( - 1, 0, 0 ) ); | |
| this.add( cameraNX ); | |
| var cameraPY = new THREE.PerspectiveCamera( fov, aspect, near, far ); | |
| cameraPY.up.set( 0, 0, 1 ); | |
| cameraPY.lookAt( new THREE.Vector3( 0, 1, 0 ) ); | |
| this.add( cameraPY ); | |
| var cameraNY = new THREE.PerspectiveCamera( fov, aspect, near, far ); | |
| cameraNY.up.set( 0, 0, - 1 ); | |
| cameraNY.lookAt( new THREE.Vector3( 0, - 1, 0 ) ); | |
| this.add( cameraNY ); | |
| var cameraPZ = new THREE.PerspectiveCamera( fov, aspect, near, far ); | |
| cameraPZ.up.set( 0, - 1, 0 ); | |
| cameraPZ.lookAt( new THREE.Vector3( 0, 0, 1 ) ); | |
| this.add( cameraPZ ); | |
| var cameraNZ = new THREE.PerspectiveCamera( fov, aspect, near, far ); | |
| cameraNZ.up.set( 0, - 1, 0 ); | |
| cameraNZ.lookAt( new THREE.Vector3( 0, 0, - 1 ) ); | |
| this.add( cameraNZ ); | |
| var options = { format: THREE.RGBFormat, magFilter: THREE.LinearFilter, minFilter: THREE.LinearFilter }; | |
| this.renderTarget = new THREE.WebGLRenderTargetCube( cubeResolution, cubeResolution, options ); | |
| this.updateCubeMap = function ( renderer, scene ) { | |
| if ( this.parent === null ) this.updateMatrixWorld(); | |
| var renderTarget = this.renderTarget; | |
| var generateMipmaps = renderTarget.texture.generateMipmaps; | |
| renderTarget.texture.generateMipmaps = false; | |
| renderTarget.activeCubeFace = 0; | |
| renderer.render( scene, cameraPX, renderTarget ); | |
| renderTarget.activeCubeFace = 1; | |
| renderer.render( scene, cameraNX, renderTarget ); | |
| renderTarget.activeCubeFace = 2; | |
| renderer.render( scene, cameraPY, renderTarget ); | |
| renderTarget.activeCubeFace = 3; | |
| renderer.render( scene, cameraNY, renderTarget ); | |
| renderTarget.activeCubeFace = 4; | |
| renderer.render( scene, cameraPZ, renderTarget ); | |
| renderTarget.texture.generateMipmaps = generateMipmaps; | |
| renderTarget.activeCubeFace = 5; | |
| renderer.render( scene, cameraNZ, renderTarget ); | |
| renderer.setRenderTarget( null ); | |
| }; | |
| }; | |
| THREE.CubeCamera.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.CubeCamera.prototype.constructor = THREE.CubeCamera; | |
| // File:src/cameras/OrthographicCamera.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.OrthographicCamera = function ( left, right, top, bottom, near, far ) { | |
| THREE.Camera.call( this ); | |
| this.type = 'OrthographicCamera'; | |
| this.zoom = 1; | |
| this.left = left; | |
| this.right = right; | |
| this.top = top; | |
| this.bottom = bottom; | |
| this.near = ( near !== undefined ) ? near : 0.1; | |
| this.far = ( far !== undefined ) ? far : 2000; | |
| this.updateProjectionMatrix(); | |
| }; | |
| THREE.OrthographicCamera.prototype = Object.create( THREE.Camera.prototype ); | |
| THREE.OrthographicCamera.prototype.constructor = THREE.OrthographicCamera; | |
| THREE.OrthographicCamera.prototype.updateProjectionMatrix = function () { | |
| var dx = ( this.right - this.left ) / ( 2 * this.zoom ); | |
| var dy = ( this.top - this.bottom ) / ( 2 * this.zoom ); | |
| var cx = ( this.right + this.left ) / 2; | |
| var cy = ( this.top + this.bottom ) / 2; | |
| this.projectionMatrix.makeOrthographic( cx - dx, cx + dx, cy + dy, cy - dy, this.near, this.far ); | |
| }; | |
| THREE.OrthographicCamera.prototype.copy = function ( source ) { | |
| THREE.Camera.prototype.copy.call( this, source ); | |
| this.left = source.left; | |
| this.right = source.right; | |
| this.top = source.top; | |
| this.bottom = source.bottom; | |
| this.near = source.near; | |
| this.far = source.far; | |
| this.zoom = source.zoom; | |
| return this; | |
| }; | |
| THREE.OrthographicCamera.prototype.toJSON = function ( meta ) { | |
| var data = THREE.Object3D.prototype.toJSON.call( this, meta ); | |
| data.object.zoom = this.zoom; | |
| data.object.left = this.left; | |
| data.object.right = this.right; | |
| data.object.top = this.top; | |
| data.object.bottom = this.bottom; | |
| data.object.near = this.near; | |
| data.object.far = this.far; | |
| return data; | |
| }; | |
| // File:src/cameras/PerspectiveCamera.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author greggman / http://games.greggman.com/ | |
| * @author zz85 / http://www.lab4games.net/zz85/blog | |
| */ | |
| THREE.PerspectiveCamera = function ( fov, aspect, near, far ) { | |
| THREE.Camera.call( this ); | |
| this.type = 'PerspectiveCamera'; | |
| this.focalLength = 10; | |
| this.zoom = 1; | |
| this.fov = fov !== undefined ? fov : 50; | |
| this.aspect = aspect !== undefined ? aspect : 1; | |
| this.near = near !== undefined ? near : 0.1; | |
| this.far = far !== undefined ? far : 2000; | |
| this.updateProjectionMatrix(); | |
| }; | |
| THREE.PerspectiveCamera.prototype = Object.create( THREE.Camera.prototype ); | |
| THREE.PerspectiveCamera.prototype.constructor = THREE.PerspectiveCamera; | |
| /** | |
| * Uses Focal Length (in mm) to estimate and set FOV | |
| * 35mm (full-frame) camera is used if frame size is not specified; | |
| * Formula based on http://www.bobatkins.com/photography/technical/field_of_view.html | |
| */ | |
| THREE.PerspectiveCamera.prototype.setLens = function ( focalLength, frameHeight ) { | |
| if ( frameHeight === undefined ) frameHeight = 24; | |
| this.fov = 2 * THREE.Math.radToDeg( Math.atan( frameHeight / ( focalLength * 2 ) ) ); | |
| this.updateProjectionMatrix(); | |
| }; | |
| /** | |
| * Sets an offset in a larger frustum. This is useful for multi-window or | |
| * multi-monitor/multi-machine setups. | |
| * | |
| * For example, if you have 3x2 monitors and each monitor is 1920x1080 and | |
| * the monitors are in grid like this | |
| * | |
| * +---+---+---+ | |
| * | A | B | C | | |
| * +---+---+---+ | |
| * | D | E | F | | |
| * +---+---+---+ | |
| * | |
| * then for each monitor you would call it like this | |
| * | |
| * var w = 1920; | |
| * var h = 1080; | |
| * var fullWidth = w * 3; | |
| * var fullHeight = h * 2; | |
| * | |
| * --A-- | |
| * camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h ); | |
| * --B-- | |
| * camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h ); | |
| * --C-- | |
| * camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h ); | |
| * --D-- | |
| * camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h ); | |
| * --E-- | |
| * camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h ); | |
| * --F-- | |
| * camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h ); | |
| * | |
| * Note there is no reason monitors have to be the same size or in a grid. | |
| */ | |
| THREE.PerspectiveCamera.prototype.setViewOffset = function ( fullWidth, fullHeight, x, y, width, height ) { | |
| this.fullWidth = fullWidth; | |
| this.fullHeight = fullHeight; | |
| this.x = x; | |
| this.y = y; | |
| this.width = width; | |
| this.height = height; | |
| this.updateProjectionMatrix(); | |
| }; | |
| THREE.PerspectiveCamera.prototype.updateProjectionMatrix = function () { | |
| var fov = THREE.Math.radToDeg( 2 * Math.atan( Math.tan( THREE.Math.degToRad( this.fov ) * 0.5 ) / this.zoom ) ); | |
| if ( this.fullWidth ) { | |
| var aspect = this.fullWidth / this.fullHeight; | |
| var top = Math.tan( THREE.Math.degToRad( fov * 0.5 ) ) * this.near; | |
| var bottom = - top; | |
| var left = aspect * bottom; | |
| var right = aspect * top; | |
| var width = Math.abs( right - left ); | |
| var height = Math.abs( top - bottom ); | |
| this.projectionMatrix.makeFrustum( | |
| left + this.x * width / this.fullWidth, | |
| left + ( this.x + this.width ) * width / this.fullWidth, | |
| top - ( this.y + this.height ) * height / this.fullHeight, | |
| top - this.y * height / this.fullHeight, | |
| this.near, | |
| this.far | |
| ); | |
| } else { | |
| this.projectionMatrix.makePerspective( fov, this.aspect, this.near, this.far ); | |
| } | |
| }; | |
| THREE.PerspectiveCamera.prototype.copy = function ( source ) { | |
| THREE.Camera.prototype.copy.call( this, source ); | |
| this.focalLength = source.focalLength; | |
| this.zoom = source.zoom; | |
| this.fov = source.fov; | |
| this.aspect = source.aspect; | |
| this.near = source.near; | |
| this.far = source.far; | |
| return this; | |
| }; | |
| THREE.PerspectiveCamera.prototype.toJSON = function ( meta ) { | |
| var data = THREE.Object3D.prototype.toJSON.call( this, meta ); | |
| data.object.focalLength = this.focalLength; | |
| data.object.zoom = this.zoom; | |
| data.object.fov = this.fov; | |
| data.object.aspect = this.aspect; | |
| data.object.near = this.near; | |
| data.object.far = this.far; | |
| return data; | |
| }; | |
| // File:src/cameras/StereoCamera.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.StereoCamera = function () { | |
| this.type = 'StereoCamera'; | |
| this.aspect = 1; | |
| this.cameraL = new THREE.PerspectiveCamera(); | |
| this.cameraL.layers.enable( 1 ); | |
| this.cameraL.matrixAutoUpdate = false; | |
| this.cameraR = new THREE.PerspectiveCamera(); | |
| this.cameraR.layers.enable( 2 ); | |
| this.cameraR.matrixAutoUpdate = false; | |
| }; | |
| THREE.StereoCamera.prototype = { | |
| constructor: THREE.StereoCamera, | |
| update: ( function () { | |
| var focalLength, fov, aspect, near, far; | |
| var eyeRight = new THREE.Matrix4(); | |
| var eyeLeft = new THREE.Matrix4(); | |
| return function update ( camera ) { | |
| var needsUpdate = focalLength !== camera.focalLength || fov !== camera.fov || | |
| aspect !== camera.aspect * this.aspect || near !== camera.near || | |
| far !== camera.far; | |
| if ( needsUpdate ) { | |
| focalLength = camera.focalLength; | |
| fov = camera.fov; | |
| aspect = camera.aspect * this.aspect; | |
| near = camera.near; | |
| far = camera.far; | |
| // Off-axis stereoscopic effect based on | |
| // http://paulbourke.net/stereographics/stereorender/ | |
| var projectionMatrix = camera.projectionMatrix.clone(); | |
| var eyeSep = 0.064 / 2; | |
| var eyeSepOnProjection = eyeSep * near / focalLength; | |
| var ymax = near * Math.tan( THREE.Math.degToRad( fov * 0.5 ) ); | |
| var xmin, xmax; | |
| // translate xOffset | |
| eyeLeft.elements[ 12 ] = - eyeSep; | |
| eyeRight.elements[ 12 ] = eyeSep; | |
| // for left eye | |
| xmin = - ymax * aspect + eyeSepOnProjection; | |
| xmax = ymax * aspect + eyeSepOnProjection; | |
| projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin ); | |
| projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin ); | |
| this.cameraL.projectionMatrix.copy( projectionMatrix ); | |
| // for right eye | |
| xmin = - ymax * aspect - eyeSepOnProjection; | |
| xmax = ymax * aspect - eyeSepOnProjection; | |
| projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin ); | |
| projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin ); | |
| this.cameraR.projectionMatrix.copy( projectionMatrix ); | |
| } | |
| this.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( eyeLeft ); | |
| this.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( eyeRight ); | |
| }; | |
| } )() | |
| }; | |
| // File:src/lights/Light.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Light = function ( color, intensity ) { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Light'; | |
| this.color = new THREE.Color( color ); | |
| this.intensity = intensity !== undefined ? intensity : 1; | |
| this.receiveShadow = undefined; | |
| }; | |
| THREE.Light.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Light.prototype.constructor = THREE.Light; | |
| THREE.Light.prototype.copy = function ( source ) { | |
| THREE.Object3D.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.intensity = source.intensity; | |
| return this; | |
| }; | |
| THREE.Light.prototype.toJSON = function ( meta ) { | |
| var data = THREE.Object3D.prototype.toJSON.call( this, meta ); | |
| data.object.color = this.color.getHex(); | |
| data.object.intensity = this.intensity; | |
| if ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex(); | |
| if ( this.distance !== undefined ) data.object.distance = this.distance; | |
| if ( this.angle !== undefined ) data.object.angle = this.angle; | |
| if ( this.decay !== undefined ) data.object.decay = this.decay; | |
| if ( this.exponent !== undefined ) data.object.exponent = this.exponent; | |
| return data; | |
| }; | |
| // File:src/lights/LightShadow.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.LightShadow = function ( camera ) { | |
| this.camera = camera; | |
| this.bias = 0; | |
| this.radius = 1; | |
| this.mapSize = new THREE.Vector2( 512, 512 ); | |
| this.map = null; | |
| this.matrix = new THREE.Matrix4(); | |
| }; | |
| THREE.LightShadow.prototype = { | |
| constructor: THREE.LightShadow, | |
| copy: function ( source ) { | |
| this.camera = source.camera.clone(); | |
| this.bias = source.bias; | |
| this.radius = source.radius; | |
| this.mapSize.copy( source.mapSize ); | |
| return this; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| } | |
| }; | |
| // File:src/lights/AmbientLight.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.AmbientLight = function ( color, intensity ) { | |
| THREE.Light.call( this, color, intensity ); | |
| this.type = 'AmbientLight'; | |
| this.castShadow = undefined; | |
| }; | |
| THREE.AmbientLight.prototype = Object.create( THREE.Light.prototype ); | |
| THREE.AmbientLight.prototype.constructor = THREE.AmbientLight; | |
| // File:src/lights/DirectionalLight.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.DirectionalLight = function ( color, intensity ) { | |
| THREE.Light.call( this, color, intensity ); | |
| this.type = 'DirectionalLight'; | |
| this.position.set( 0, 1, 0 ); | |
| this.updateMatrix(); | |
| this.target = new THREE.Object3D(); | |
| this.shadow = new THREE.LightShadow( new THREE.OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) ); | |
| }; | |
| THREE.DirectionalLight.prototype = Object.create( THREE.Light.prototype ); | |
| THREE.DirectionalLight.prototype.constructor = THREE.DirectionalLight; | |
| THREE.DirectionalLight.prototype.copy = function ( source ) { | |
| THREE.Light.prototype.copy.call( this, source ); | |
| this.target = source.target.clone(); | |
| this.shadow = source.shadow.clone(); | |
| return this; | |
| }; | |
| // File:src/lights/HemisphereLight.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.HemisphereLight = function ( skyColor, groundColor, intensity ) { | |
| THREE.Light.call( this, skyColor, intensity ); | |
| this.type = 'HemisphereLight'; | |
| this.castShadow = undefined; | |
| this.position.set( 0, 1, 0 ); | |
| this.updateMatrix(); | |
| this.groundColor = new THREE.Color( groundColor ); | |
| }; | |
| THREE.HemisphereLight.prototype = Object.create( THREE.Light.prototype ); | |
| THREE.HemisphereLight.prototype.constructor = THREE.HemisphereLight; | |
| THREE.HemisphereLight.prototype.copy = function ( source ) { | |
| THREE.Light.prototype.copy.call( this, source ); | |
| this.groundColor.copy( source.groundColor ); | |
| return this; | |
| }; | |
| // File:src/lights/PointLight.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.PointLight = function ( color, intensity, distance, decay ) { | |
| THREE.Light.call( this, color, intensity ); | |
| this.type = 'PointLight'; | |
| this.distance = ( distance !== undefined ) ? distance : 0; | |
| this.decay = ( decay !== undefined ) ? decay : 1; // for physically correct lights, should be 2. | |
| this.shadow = new THREE.LightShadow( new THREE.PerspectiveCamera( 90, 1, 0.5, 500 ) ); | |
| }; | |
| THREE.PointLight.prototype = Object.create( THREE.Light.prototype ); | |
| THREE.PointLight.prototype.constructor = THREE.PointLight; | |
| THREE.PointLight.prototype.copy = function ( source ) { | |
| THREE.Light.prototype.copy.call( this, source ); | |
| this.distance = source.distance; | |
| this.decay = source.decay; | |
| this.shadow = source.shadow.clone(); | |
| return this; | |
| }; | |
| // File:src/lights/SpotLight.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.SpotLight = function ( color, intensity, distance, angle, exponent, decay ) { | |
| THREE.Light.call( this, color, intensity ); | |
| this.type = 'SpotLight'; | |
| this.position.set( 0, 1, 0 ); | |
| this.updateMatrix(); | |
| this.target = new THREE.Object3D(); | |
| this.distance = ( distance !== undefined ) ? distance : 0; | |
| this.angle = ( angle !== undefined ) ? angle : Math.PI / 3; | |
| this.exponent = ( exponent !== undefined ) ? exponent : 10; | |
| this.decay = ( decay !== undefined ) ? decay : 1; // for physically correct lights, should be 2. | |
| this.shadow = new THREE.LightShadow( new THREE.PerspectiveCamera( 50, 1, 0.5, 500 ) ); | |
| }; | |
| THREE.SpotLight.prototype = Object.create( THREE.Light.prototype ); | |
| THREE.SpotLight.prototype.constructor = THREE.SpotLight; | |
| THREE.SpotLight.prototype.copy = function ( source ) { | |
| THREE.Light.prototype.copy.call( this, source ); | |
| this.distance = source.distance; | |
| this.angle = source.angle; | |
| this.exponent = source.exponent; | |
| this.decay = source.decay; | |
| this.target = source.target.clone(); | |
| this.shadow = source.shadow.clone(); | |
| return this; | |
| }; | |
| // File:src/loaders/Cache.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Cache = { | |
| enabled: false, | |
| files: {}, | |
| add: function ( key, file ) { | |
| if ( this.enabled === false ) return; | |
| // console.log( 'THREE.Cache', 'Adding key:', key ); | |
| this.files[ key ] = file; | |
| }, | |
| get: function ( key ) { | |
| if ( this.enabled === false ) return; | |
| // console.log( 'THREE.Cache', 'Checking key:', key ); | |
| return this.files[ key ]; | |
| }, | |
| remove: function ( key ) { | |
| delete this.files[ key ]; | |
| }, | |
| clear: function () { | |
| this.files = {}; | |
| } | |
| }; | |
| // File:src/loaders/Loader.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Loader = function () { | |
| this.onLoadStart = function () {}; | |
| this.onLoadProgress = function () {}; | |
| this.onLoadComplete = function () {}; | |
| }; | |
| THREE.Loader.prototype = { | |
| constructor: THREE.Loader, | |
| crossOrigin: undefined, | |
| extractUrlBase: function ( url ) { | |
| var parts = url.split( '/' ); | |
| if ( parts.length === 1 ) return './'; | |
| parts.pop(); | |
| return parts.join( '/' ) + '/'; | |
| }, | |
| initMaterials: function ( materials, texturePath, crossOrigin ) { | |
| var array = []; | |
| for ( var i = 0; i < materials.length; ++ i ) { | |
| array[ i ] = this.createMaterial( materials[ i ], texturePath, crossOrigin ); | |
| } | |
| return array; | |
| }, | |
| createMaterial: ( function () { | |
| var color, textureLoader, materialLoader; | |
| return function ( m, texturePath, crossOrigin ) { | |
| if ( color === undefined ) color = new THREE.Color(); | |
| if ( textureLoader === undefined ) textureLoader = new THREE.TextureLoader(); | |
| if ( materialLoader === undefined ) materialLoader = new THREE.MaterialLoader(); | |
| // convert from old material format | |
| var textures = {}; | |
| function loadTexture( path, repeat, offset, wrap, anisotropy ) { | |
| var fullPath = texturePath + path; | |
| var loader = THREE.Loader.Handlers.get( fullPath ); | |
| var texture; | |
| if ( loader !== null ) { | |
| texture = loader.load( fullPath ); | |
| } else { | |
| textureLoader.setCrossOrigin( crossOrigin ); | |
| texture = textureLoader.load( fullPath ); | |
| } | |
| if ( repeat !== undefined ) { | |
| texture.repeat.fromArray( repeat ); | |
| if ( repeat[ 0 ] !== 1 ) texture.wrapS = THREE.RepeatWrapping; | |
| if ( repeat[ 1 ] !== 1 ) texture.wrapT = THREE.RepeatWrapping; | |
| } | |
| if ( offset !== undefined ) { | |
| texture.offset.fromArray( offset ); | |
| } | |
| if ( wrap !== undefined ) { | |
| if ( wrap[ 0 ] === 'repeat' ) texture.wrapS = THREE.RepeatWrapping; | |
| if ( wrap[ 0 ] === 'mirror' ) texture.wrapS = THREE.MirroredRepeatWrapping; | |
| if ( wrap[ 1 ] === 'repeat' ) texture.wrapT = THREE.RepeatWrapping; | |
| if ( wrap[ 1 ] === 'mirror' ) texture.wrapT = THREE.MirroredRepeatWrapping; | |
| } | |
| if ( anisotropy !== undefined ) { | |
| texture.anisotropy = anisotropy; | |
| } | |
| var uuid = THREE.Math.generateUUID(); | |
| textures[ uuid ] = texture; | |
| return uuid; | |
| } | |
| // | |
| var json = { | |
| uuid: THREE.Math.generateUUID(), | |
| type: 'MeshLambertMaterial' | |
| }; | |
| for ( var name in m ) { | |
| var value = m[ name ]; | |
| switch ( name ) { | |
| case 'DbgColor': | |
| case 'DbgIndex': | |
| case 'opticalDensity': | |
| case 'illumination': | |
| break; | |
| case 'DbgName': | |
| json.name = value; | |
| break; | |
| case 'blending': | |
| json.blending = THREE[ value ]; | |
| break; | |
| case 'colorAmbient': | |
| console.warn( 'THREE.Loader.createMaterial: colorAmbient is no longer supported' ); | |
| break; | |
| case 'colorDiffuse': | |
| json.color = color.fromArray( value ).getHex(); | |
| break; | |
| case 'colorSpecular': | |
| json.specular = color.fromArray( value ).getHex(); | |
| break; | |
| case 'colorEmissive': | |
| json.emissive = color.fromArray( value ).getHex(); | |
| break; | |
| case 'specularCoef': | |
| json.shininess = value; | |
| break; | |
| case 'shading': | |
| if ( value.toLowerCase() === 'basic' ) json.type = 'MeshBasicMaterial'; | |
| if ( value.toLowerCase() === 'phong' ) json.type = 'MeshPhongMaterial'; | |
| break; | |
| case 'mapDiffuse': | |
| json.map = loadTexture( value, m.mapDiffuseRepeat, m.mapDiffuseOffset, m.mapDiffuseWrap, m.mapDiffuseAnisotropy ); | |
| break; | |
| case 'mapDiffuseRepeat': | |
| case 'mapDiffuseOffset': | |
| case 'mapDiffuseWrap': | |
| case 'mapDiffuseAnisotropy': | |
| break; | |
| case 'mapLight': | |
| json.lightMap = loadTexture( value, m.mapLightRepeat, m.mapLightOffset, m.mapLightWrap, m.mapLightAnisotropy ); | |
| break; | |
| case 'mapLightRepeat': | |
| case 'mapLightOffset': | |
| case 'mapLightWrap': | |
| case 'mapLightAnisotropy': | |
| break; | |
| case 'mapAO': | |
| json.aoMap = loadTexture( value, m.mapAORepeat, m.mapAOOffset, m.mapAOWrap, m.mapAOAnisotropy ); | |
| break; | |
| case 'mapAORepeat': | |
| case 'mapAOOffset': | |
| case 'mapAOWrap': | |
| case 'mapAOAnisotropy': | |
| break; | |
| case 'mapBump': | |
| json.bumpMap = loadTexture( value, m.mapBumpRepeat, m.mapBumpOffset, m.mapBumpWrap, m.mapBumpAnisotropy ); | |
| break; | |
| case 'mapBumpScale': | |
| json.bumpScale = value; | |
| break; | |
| case 'mapBumpRepeat': | |
| case 'mapBumpOffset': | |
| case 'mapBumpWrap': | |
| case 'mapBumpAnisotropy': | |
| break; | |
| case 'mapNormal': | |
| json.normalMap = loadTexture( value, m.mapNormalRepeat, m.mapNormalOffset, m.mapNormalWrap, m.mapNormalAnisotropy ); | |
| break; | |
| case 'mapNormalFactor': | |
| json.normalScale = [ value, value ]; | |
| break; | |
| case 'mapNormalRepeat': | |
| case 'mapNormalOffset': | |
| case 'mapNormalWrap': | |
| case 'mapNormalAnisotropy': | |
| break; | |
| case 'mapSpecular': | |
| json.specularMap = loadTexture( value, m.mapSpecularRepeat, m.mapSpecularOffset, m.mapSpecularWrap, m.mapSpecularAnisotropy ); | |
| break; | |
| case 'mapSpecularRepeat': | |
| case 'mapSpecularOffset': | |
| case 'mapSpecularWrap': | |
| case 'mapSpecularAnisotropy': | |
| break; | |
| case 'mapAlpha': | |
| json.alphaMap = loadTexture( value, m.mapAlphaRepeat, m.mapAlphaOffset, m.mapAlphaWrap, m.mapAlphaAnisotropy ); | |
| break; | |
| case 'mapAlphaRepeat': | |
| case 'mapAlphaOffset': | |
| case 'mapAlphaWrap': | |
| case 'mapAlphaAnisotropy': | |
| break; | |
| case 'flipSided': | |
| json.side = THREE.BackSide; | |
| break; | |
| case 'doubleSided': | |
| json.side = THREE.DoubleSide; | |
| break; | |
| case 'transparency': | |
| console.warn( 'THREE.Loader.createMaterial: transparency has been renamed to opacity' ); | |
| json.opacity = value; | |
| break; | |
| case 'depthTest': | |
| case 'depthWrite': | |
| case 'colorWrite': | |
| case 'opacity': | |
| case 'reflectivity': | |
| case 'transparent': | |
| case 'visible': | |
| case 'wireframe': | |
| json[ name ] = value; | |
| break; | |
| case 'vertexColors': | |
| if ( value === true ) json.vertexColors = THREE.VertexColors; | |
| if ( value === 'face' ) json.vertexColors = THREE.FaceColors; | |
| break; | |
| default: | |
| console.error( 'THREE.Loader.createMaterial: Unsupported', name, value ); | |
| break; | |
| } | |
| } | |
| if ( json.type === 'MeshBasicMaterial' ) delete json.emissive; | |
| if ( json.type !== 'MeshPhongMaterial' ) delete json.specular; | |
| if ( json.opacity < 1 ) json.transparent = true; | |
| materialLoader.setTextures( textures ); | |
| return materialLoader.parse( json ); | |
| }; | |
| } )() | |
| }; | |
| THREE.Loader.Handlers = { | |
| handlers: [], | |
| add: function ( regex, loader ) { | |
| this.handlers.push( regex, loader ); | |
| }, | |
| get: function ( file ) { | |
| var handlers = this.handlers; | |
| for ( var i = 0, l = handlers.length; i < l; i += 2 ) { | |
| var regex = handlers[ i ]; | |
| var loader = handlers[ i + 1 ]; | |
| if ( regex.test( file ) ) { | |
| return loader; | |
| } | |
| } | |
| return null; | |
| } | |
| }; | |
| // File:src/loaders/XHRLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.XHRLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| }; | |
| THREE.XHRLoader.prototype = { | |
| constructor: THREE.XHRLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| if ( this.path !== undefined ) url = this.path + url; | |
| var scope = this; | |
| var cached = THREE.Cache.get( url ); | |
| if ( cached !== undefined ) { | |
| if ( onLoad ) { | |
| setTimeout( function () { | |
| onLoad( cached ); | |
| }, 0 ); | |
| } | |
| return cached; | |
| } | |
| var request = new XMLHttpRequest(); | |
| request.overrideMimeType( 'text/plain' ); | |
| request.open( 'GET', url, true ); | |
| request.addEventListener( 'load', function ( event ) { | |
| var response = event.target.response; | |
| THREE.Cache.add( url, response ); | |
| if ( this.status === 200 ) { | |
| if ( onLoad ) onLoad( response ); | |
| scope.manager.itemEnd( url ); | |
| } else if ( this.status === 0 ) { | |
| // Some browsers return HTTP Status 0 when using non-http protocol | |
| // e.g. 'file://' or 'data://'. Handle as success. | |
| console.warn( 'THREE.XHRLoader: HTTP Status 0 received.' ); | |
| if ( onLoad ) onLoad( response ); | |
| scope.manager.itemEnd( url ); | |
| } else { | |
| if ( onError ) onError( event ); | |
| scope.manager.itemError( url ); | |
| } | |
| }, false ); | |
| if ( onProgress !== undefined ) { | |
| request.addEventListener( 'progress', function ( event ) { | |
| onProgress( event ); | |
| }, false ); | |
| } | |
| request.addEventListener( 'error', function ( event ) { | |
| if ( onError ) onError( event ); | |
| scope.manager.itemError( url ); | |
| }, false ); | |
| if ( this.responseType !== undefined ) request.responseType = this.responseType; | |
| if ( this.withCredentials !== undefined ) request.withCredentials = this.withCredentials; | |
| request.send( null ); | |
| scope.manager.itemStart( url ); | |
| return request; | |
| }, | |
| setPath: function ( value ) { | |
| this.path = value; | |
| }, | |
| setResponseType: function ( value ) { | |
| this.responseType = value; | |
| }, | |
| setWithCredentials: function ( value ) { | |
| this.withCredentials = value; | |
| } | |
| }; | |
| // File:src/loaders/FontLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.FontLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| }; | |
| THREE.FontLoader.prototype = { | |
| constructor: THREE.FontLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var loader = new THREE.XHRLoader( this.manager ); | |
| loader.load( url, function ( text ) { | |
| onLoad( new THREE.Font( JSON.parse( text.substring( 65, text.length - 2 ) ) ) ); | |
| }, onProgress, onError ); | |
| } | |
| }; | |
| // File:src/loaders/ImageLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.ImageLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| }; | |
| THREE.ImageLoader.prototype = { | |
| constructor: THREE.ImageLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| if ( this.path !== undefined ) url = this.path + url; | |
| var scope = this; | |
| var cached = THREE.Cache.get( url ); | |
| if ( cached !== undefined ) { | |
| scope.manager.itemStart( url ); | |
| if ( onLoad ) { | |
| setTimeout( function () { | |
| onLoad( cached ); | |
| scope.manager.itemEnd( url ); | |
| }, 0 ); | |
| } else { | |
| scope.manager.itemEnd( url ); | |
| } | |
| return cached; | |
| } | |
| var image = document.createElement( 'img' ); | |
| image.addEventListener( 'load', function ( event ) { | |
| THREE.Cache.add( url, this ); | |
| if ( onLoad ) onLoad( this ); | |
| scope.manager.itemEnd( url ); | |
| }, false ); | |
| if ( onProgress !== undefined ) { | |
| image.addEventListener( 'progress', function ( event ) { | |
| onProgress( event ); | |
| }, false ); | |
| } | |
| image.addEventListener( 'error', function ( event ) { | |
| if ( onError ) onError( event ); | |
| scope.manager.itemError( url ); | |
| }, false ); | |
| if ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin; | |
| scope.manager.itemStart( url ); | |
| image.src = url; | |
| return image; | |
| }, | |
| setCrossOrigin: function ( value ) { | |
| this.crossOrigin = value; | |
| }, | |
| setPath: function ( value ) { | |
| this.path = value; | |
| } | |
| }; | |
| // File:src/loaders/JSONLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.JSONLoader = function ( manager ) { | |
| if ( typeof manager === 'boolean' ) { | |
| console.warn( 'THREE.JSONLoader: showStatus parameter has been removed from constructor.' ); | |
| manager = undefined; | |
| } | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| this.withCredentials = false; | |
| }; | |
| THREE.JSONLoader.prototype = { | |
| constructor: THREE.JSONLoader, | |
| // Deprecated | |
| get statusDomElement () { | |
| if ( this._statusDomElement === undefined ) { | |
| this._statusDomElement = document.createElement( 'div' ); | |
| } | |
| console.warn( 'THREE.JSONLoader: .statusDomElement has been removed.' ); | |
| return this._statusDomElement; | |
| }, | |
| load: function( url, onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var texturePath = this.texturePath && ( typeof this.texturePath === "string" ) ? this.texturePath : THREE.Loader.prototype.extractUrlBase( url ); | |
| var loader = new THREE.XHRLoader( this.manager ); | |
| loader.setWithCredentials( this.withCredentials ); | |
| loader.load( url, function ( text ) { | |
| var json = JSON.parse( text ); | |
| var metadata = json.metadata; | |
| if ( metadata !== undefined ) { | |
| var type = metadata.type; | |
| if ( type !== undefined ) { | |
| if ( type.toLowerCase() === 'object' ) { | |
| console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.ObjectLoader instead.' ); | |
| return; | |
| } | |
| if ( type.toLowerCase() === 'scene' ) { | |
| console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.SceneLoader instead.' ); | |
| return; | |
| } | |
| } | |
| } | |
| var object = scope.parse( json, texturePath ); | |
| onLoad( object.geometry, object.materials ); | |
| }, onProgress, onError ); | |
| }, | |
| setTexturePath: function ( value ) { | |
| this.texturePath = value; | |
| }, | |
| parse: function ( json, texturePath ) { | |
| var geometry = new THREE.Geometry(), | |
| scale = ( json.scale !== undefined ) ? 1.0 / json.scale : 1.0; | |
| parseModel( scale ); | |
| parseSkin(); | |
| parseMorphing( scale ); | |
| parseAnimations(); | |
| geometry.computeFaceNormals(); | |
| geometry.computeBoundingSphere(); | |
| function parseModel( scale ) { | |
| function isBitSet( value, position ) { | |
| return value & ( 1 << position ); | |
| } | |
| var i, j, fi, | |
| offset, zLength, | |
| colorIndex, normalIndex, uvIndex, materialIndex, | |
| type, | |
| isQuad, | |
| hasMaterial, | |
| hasFaceVertexUv, | |
| hasFaceNormal, hasFaceVertexNormal, | |
| hasFaceColor, hasFaceVertexColor, | |
| vertex, face, faceA, faceB, hex, normal, | |
| uvLayer, uv, u, v, | |
| faces = json.faces, | |
| vertices = json.vertices, | |
| normals = json.normals, | |
| colors = json.colors, | |
| nUvLayers = 0; | |
| if ( json.uvs !== undefined ) { | |
| // disregard empty arrays | |
| for ( i = 0; i < json.uvs.length; i ++ ) { | |
| if ( json.uvs[ i ].length ) nUvLayers ++; | |
| } | |
| for ( i = 0; i < nUvLayers; i ++ ) { | |
| geometry.faceVertexUvs[ i ] = []; | |
| } | |
| } | |
| offset = 0; | |
| zLength = vertices.length; | |
| while ( offset < zLength ) { | |
| vertex = new THREE.Vector3(); | |
| vertex.x = vertices[ offset ++ ] * scale; | |
| vertex.y = vertices[ offset ++ ] * scale; | |
| vertex.z = vertices[ offset ++ ] * scale; | |
| geometry.vertices.push( vertex ); | |
| } | |
| offset = 0; | |
| zLength = faces.length; | |
| while ( offset < zLength ) { | |
| type = faces[ offset ++ ]; | |
| isQuad = isBitSet( type, 0 ); | |
| hasMaterial = isBitSet( type, 1 ); | |
| hasFaceVertexUv = isBitSet( type, 3 ); | |
| hasFaceNormal = isBitSet( type, 4 ); | |
| hasFaceVertexNormal = isBitSet( type, 5 ); | |
| hasFaceColor = isBitSet( type, 6 ); | |
| hasFaceVertexColor = isBitSet( type, 7 ); | |
| // console.log("type", type, "bits", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor); | |
| if ( isQuad ) { | |
| faceA = new THREE.Face3(); | |
| faceA.a = faces[ offset ]; | |
| faceA.b = faces[ offset + 1 ]; | |
| faceA.c = faces[ offset + 3 ]; | |
| faceB = new THREE.Face3(); | |
| faceB.a = faces[ offset + 1 ]; | |
| faceB.b = faces[ offset + 2 ]; | |
| faceB.c = faces[ offset + 3 ]; | |
| offset += 4; | |
| if ( hasMaterial ) { | |
| materialIndex = faces[ offset ++ ]; | |
| faceA.materialIndex = materialIndex; | |
| faceB.materialIndex = materialIndex; | |
| } | |
| // to get face <=> uv index correspondence | |
| fi = geometry.faces.length; | |
| if ( hasFaceVertexUv ) { | |
| for ( i = 0; i < nUvLayers; i ++ ) { | |
| uvLayer = json.uvs[ i ]; | |
| geometry.faceVertexUvs[ i ][ fi ] = []; | |
| geometry.faceVertexUvs[ i ][ fi + 1 ] = []; | |
| for ( j = 0; j < 4; j ++ ) { | |
| uvIndex = faces[ offset ++ ]; | |
| u = uvLayer[ uvIndex * 2 ]; | |
| v = uvLayer[ uvIndex * 2 + 1 ]; | |
| uv = new THREE.Vector2( u, v ); | |
| if ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv ); | |
| if ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv ); | |
| } | |
| } | |
| } | |
| if ( hasFaceNormal ) { | |
| normalIndex = faces[ offset ++ ] * 3; | |
| faceA.normal.set( | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ] | |
| ); | |
| faceB.normal.copy( faceA.normal ); | |
| } | |
| if ( hasFaceVertexNormal ) { | |
| for ( i = 0; i < 4; i ++ ) { | |
| normalIndex = faces[ offset ++ ] * 3; | |
| normal = new THREE.Vector3( | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ] | |
| ); | |
| if ( i !== 2 ) faceA.vertexNormals.push( normal ); | |
| if ( i !== 0 ) faceB.vertexNormals.push( normal ); | |
| } | |
| } | |
| if ( hasFaceColor ) { | |
| colorIndex = faces[ offset ++ ]; | |
| hex = colors[ colorIndex ]; | |
| faceA.color.setHex( hex ); | |
| faceB.color.setHex( hex ); | |
| } | |
| if ( hasFaceVertexColor ) { | |
| for ( i = 0; i < 4; i ++ ) { | |
| colorIndex = faces[ offset ++ ]; | |
| hex = colors[ colorIndex ]; | |
| if ( i !== 2 ) faceA.vertexColors.push( new THREE.Color( hex ) ); | |
| if ( i !== 0 ) faceB.vertexColors.push( new THREE.Color( hex ) ); | |
| } | |
| } | |
| geometry.faces.push( faceA ); | |
| geometry.faces.push( faceB ); | |
| } else { | |
| face = new THREE.Face3(); | |
| face.a = faces[ offset ++ ]; | |
| face.b = faces[ offset ++ ]; | |
| face.c = faces[ offset ++ ]; | |
| if ( hasMaterial ) { | |
| materialIndex = faces[ offset ++ ]; | |
| face.materialIndex = materialIndex; | |
| } | |
| // to get face <=> uv index correspondence | |
| fi = geometry.faces.length; | |
| if ( hasFaceVertexUv ) { | |
| for ( i = 0; i < nUvLayers; i ++ ) { | |
| uvLayer = json.uvs[ i ]; | |
| geometry.faceVertexUvs[ i ][ fi ] = []; | |
| for ( j = 0; j < 3; j ++ ) { | |
| uvIndex = faces[ offset ++ ]; | |
| u = uvLayer[ uvIndex * 2 ]; | |
| v = uvLayer[ uvIndex * 2 + 1 ]; | |
| uv = new THREE.Vector2( u, v ); | |
| geometry.faceVertexUvs[ i ][ fi ].push( uv ); | |
| } | |
| } | |
| } | |
| if ( hasFaceNormal ) { | |
| normalIndex = faces[ offset ++ ] * 3; | |
| face.normal.set( | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ] | |
| ); | |
| } | |
| if ( hasFaceVertexNormal ) { | |
| for ( i = 0; i < 3; i ++ ) { | |
| normalIndex = faces[ offset ++ ] * 3; | |
| normal = new THREE.Vector3( | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ++ ], | |
| normals[ normalIndex ] | |
| ); | |
| face.vertexNormals.push( normal ); | |
| } | |
| } | |
| if ( hasFaceColor ) { | |
| colorIndex = faces[ offset ++ ]; | |
| face.color.setHex( colors[ colorIndex ] ); | |
| } | |
| if ( hasFaceVertexColor ) { | |
| for ( i = 0; i < 3; i ++ ) { | |
| colorIndex = faces[ offset ++ ]; | |
| face.vertexColors.push( new THREE.Color( colors[ colorIndex ] ) ); | |
| } | |
| } | |
| geometry.faces.push( face ); | |
| } | |
| } | |
| }; | |
| function parseSkin() { | |
| var influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2; | |
| if ( json.skinWeights ) { | |
| for ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) { | |
| var x = json.skinWeights[ i ]; | |
| var y = ( influencesPerVertex > 1 ) ? json.skinWeights[ i + 1 ] : 0; | |
| var z = ( influencesPerVertex > 2 ) ? json.skinWeights[ i + 2 ] : 0; | |
| var w = ( influencesPerVertex > 3 ) ? json.skinWeights[ i + 3 ] : 0; | |
| geometry.skinWeights.push( new THREE.Vector4( x, y, z, w ) ); | |
| } | |
| } | |
| if ( json.skinIndices ) { | |
| for ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) { | |
| var a = json.skinIndices[ i ]; | |
| var b = ( influencesPerVertex > 1 ) ? json.skinIndices[ i + 1 ] : 0; | |
| var c = ( influencesPerVertex > 2 ) ? json.skinIndices[ i + 2 ] : 0; | |
| var d = ( influencesPerVertex > 3 ) ? json.skinIndices[ i + 3 ] : 0; | |
| geometry.skinIndices.push( new THREE.Vector4( a, b, c, d ) ); | |
| } | |
| } | |
| geometry.bones = json.bones; | |
| if ( geometry.bones && geometry.bones.length > 0 && ( geometry.skinWeights.length !== geometry.skinIndices.length || geometry.skinIndices.length !== geometry.vertices.length ) ) { | |
| console.warn( 'When skinning, number of vertices (' + geometry.vertices.length + '), skinIndices (' + | |
| geometry.skinIndices.length + '), and skinWeights (' + geometry.skinWeights.length + ') should match.' ); | |
| } | |
| }; | |
| function parseMorphing( scale ) { | |
| if ( json.morphTargets !== undefined ) { | |
| for ( var i = 0, l = json.morphTargets.length; i < l; i ++ ) { | |
| geometry.morphTargets[ i ] = {}; | |
| geometry.morphTargets[ i ].name = json.morphTargets[ i ].name; | |
| geometry.morphTargets[ i ].vertices = []; | |
| var dstVertices = geometry.morphTargets[ i ].vertices; | |
| var srcVertices = json.morphTargets[ i ].vertices; | |
| for ( var v = 0, vl = srcVertices.length; v < vl; v += 3 ) { | |
| var vertex = new THREE.Vector3(); | |
| vertex.x = srcVertices[ v ] * scale; | |
| vertex.y = srcVertices[ v + 1 ] * scale; | |
| vertex.z = srcVertices[ v + 2 ] * scale; | |
| dstVertices.push( vertex ); | |
| } | |
| } | |
| } | |
| if ( json.morphColors !== undefined && json.morphColors.length > 0 ) { | |
| console.warn( 'THREE.JSONLoader: "morphColors" no longer supported. Using them as face colors.' ); | |
| var faces = geometry.faces; | |
| var morphColors = json.morphColors[ 0 ].colors; | |
| for ( var i = 0, l = faces.length; i < l; i ++ ) { | |
| faces[ i ].color.fromArray( morphColors, i * 3 ); | |
| } | |
| } | |
| } | |
| function parseAnimations() { | |
| var outputAnimations = []; | |
| // parse old style Bone/Hierarchy animations | |
| var animations = []; | |
| if ( json.animation !== undefined ) { | |
| animations.push( json.animation ); | |
| } | |
| if ( json.animations !== undefined ) { | |
| if ( json.animations.length ) { | |
| animations = animations.concat( json.animations ); | |
| } else { | |
| animations.push( json.animations ); | |
| } | |
| } | |
| for ( var i = 0; i < animations.length; i ++ ) { | |
| var clip = THREE.AnimationClip.parseAnimation( animations[ i ], geometry.bones ); | |
| if ( clip ) outputAnimations.push( clip ); | |
| } | |
| // parse implicit morph animations | |
| if ( geometry.morphTargets ) { | |
| // TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary. | |
| var morphAnimationClips = THREE.AnimationClip.CreateClipsFromMorphTargetSequences( geometry.morphTargets, 10 ); | |
| outputAnimations = outputAnimations.concat( morphAnimationClips ); | |
| } | |
| if ( outputAnimations.length > 0 ) geometry.animations = outputAnimations; | |
| }; | |
| if ( json.materials === undefined || json.materials.length === 0 ) { | |
| return { geometry: geometry }; | |
| } else { | |
| var materials = THREE.Loader.prototype.initMaterials( json.materials, texturePath, this.crossOrigin ); | |
| return { geometry: geometry, materials: materials }; | |
| } | |
| } | |
| }; | |
| // File:src/loaders/LoadingManager.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.LoadingManager = function ( onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var isLoading = false, itemsLoaded = 0, itemsTotal = 0; | |
| this.onStart = undefined; | |
| this.onLoad = onLoad; | |
| this.onProgress = onProgress; | |
| this.onError = onError; | |
| this.itemStart = function ( url ) { | |
| itemsTotal ++; | |
| if ( isLoading === false ) { | |
| if ( scope.onStart !== undefined ) { | |
| scope.onStart( url, itemsLoaded, itemsTotal ); | |
| } | |
| } | |
| isLoading = true; | |
| }; | |
| this.itemEnd = function ( url ) { | |
| itemsLoaded ++; | |
| if ( scope.onProgress !== undefined ) { | |
| scope.onProgress( url, itemsLoaded, itemsTotal ); | |
| } | |
| if ( itemsLoaded === itemsTotal ) { | |
| isLoading = false; | |
| if ( scope.onLoad !== undefined ) { | |
| scope.onLoad(); | |
| } | |
| } | |
| }; | |
| this.itemError = function ( url ) { | |
| if ( scope.onError !== undefined ) { | |
| scope.onError( url ); | |
| } | |
| }; | |
| }; | |
| THREE.DefaultLoadingManager = new THREE.LoadingManager(); | |
| // File:src/loaders/BufferGeometryLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.BufferGeometryLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| }; | |
| THREE.BufferGeometryLoader.prototype = { | |
| constructor: THREE.BufferGeometryLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var loader = new THREE.XHRLoader( scope.manager ); | |
| loader.load( url, function ( text ) { | |
| onLoad( scope.parse( JSON.parse( text ) ) ); | |
| }, onProgress, onError ); | |
| }, | |
| parse: function ( json ) { | |
| var geometry = new THREE.BufferGeometry(); | |
| var index = json.data.index; | |
| var TYPED_ARRAYS = { | |
| 'Int8Array': Int8Array, | |
| 'Uint8Array': Uint8Array, | |
| 'Uint8ClampedArray': Uint8ClampedArray, | |
| 'Int16Array': Int16Array, | |
| 'Uint16Array': Uint16Array, | |
| 'Int32Array': Int32Array, | |
| 'Uint32Array': Uint32Array, | |
| 'Float32Array': Float32Array, | |
| 'Float64Array': Float64Array | |
| }; | |
| if ( index !== undefined ) { | |
| var typedArray = new TYPED_ARRAYS[ index.type ]( index.array ); | |
| geometry.setIndex( new THREE.BufferAttribute( typedArray, 1 ) ); | |
| } | |
| var attributes = json.data.attributes; | |
| for ( var key in attributes ) { | |
| var attribute = attributes[ key ]; | |
| var typedArray = new TYPED_ARRAYS[ attribute.type ]( attribute.array ); | |
| geometry.addAttribute( key, new THREE.BufferAttribute( typedArray, attribute.itemSize ) ); | |
| } | |
| var groups = json.data.groups || json.data.drawcalls || json.data.offsets; | |
| if ( groups !== undefined ) { | |
| for ( var i = 0, n = groups.length; i !== n; ++ i ) { | |
| var group = groups[ i ]; | |
| geometry.addGroup( group.start, group.count, group.materialIndex ); | |
| } | |
| } | |
| var boundingSphere = json.data.boundingSphere; | |
| if ( boundingSphere !== undefined ) { | |
| var center = new THREE.Vector3(); | |
| if ( boundingSphere.center !== undefined ) { | |
| center.fromArray( boundingSphere.center ); | |
| } | |
| geometry.boundingSphere = new THREE.Sphere( center, boundingSphere.radius ); | |
| } | |
| return geometry; | |
| } | |
| }; | |
| // File:src/loaders/MaterialLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.MaterialLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| this.textures = {}; | |
| }; | |
| THREE.MaterialLoader.prototype = { | |
| constructor: THREE.MaterialLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var loader = new THREE.XHRLoader( scope.manager ); | |
| loader.load( url, function ( text ) { | |
| onLoad( scope.parse( JSON.parse( text ) ) ); | |
| }, onProgress, onError ); | |
| }, | |
| setTextures: function ( value ) { | |
| this.textures = value; | |
| }, | |
| getTexture: function ( name ) { | |
| var textures = this.textures; | |
| if ( textures[ name ] === undefined ) { | |
| console.warn( 'THREE.MaterialLoader: Undefined texture', name ); | |
| } | |
| return textures[ name ]; | |
| }, | |
| parse: function ( json ) { | |
| var material = new THREE[ json.type ]; | |
| if ( json.uuid !== undefined ) material.uuid = json.uuid; | |
| if ( json.name !== undefined ) material.name = json.name; | |
| if ( json.color !== undefined ) material.color.setHex( json.color ); | |
| if ( json.roughness !== undefined ) material.roughness = json.roughness; | |
| if ( json.metalness !== undefined ) material.metalness = json.metalness; | |
| if ( json.emissive !== undefined ) material.emissive.setHex( json.emissive ); | |
| if ( json.specular !== undefined ) material.specular.setHex( json.specular ); | |
| if ( json.shininess !== undefined ) material.shininess = json.shininess; | |
| if ( json.uniforms !== undefined ) material.uniforms = json.uniforms; | |
| if ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader; | |
| if ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader; | |
| if ( json.vertexColors !== undefined ) material.vertexColors = json.vertexColors; | |
| if ( json.shading !== undefined ) material.shading = json.shading; | |
| if ( json.blending !== undefined ) material.blending = json.blending; | |
| if ( json.side !== undefined ) material.side = json.side; | |
| if ( json.opacity !== undefined ) material.opacity = json.opacity; | |
| if ( json.transparent !== undefined ) material.transparent = json.transparent; | |
| if ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest; | |
| if ( json.depthTest !== undefined ) material.depthTest = json.depthTest; | |
| if ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite; | |
| if ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite; | |
| if ( json.wireframe !== undefined ) material.wireframe = json.wireframe; | |
| if ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth; | |
| // for PointsMaterial | |
| if ( json.size !== undefined ) material.size = json.size; | |
| if ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation; | |
| // maps | |
| if ( json.map !== undefined ) material.map = this.getTexture( json.map ); | |
| if ( json.alphaMap !== undefined ) { | |
| material.alphaMap = this.getTexture( json.alphaMap ); | |
| material.transparent = true; | |
| } | |
| if ( json.bumpMap !== undefined ) material.bumpMap = this.getTexture( json.bumpMap ); | |
| if ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale; | |
| if ( json.normalMap !== undefined ) material.normalMap = this.getTexture( json.normalMap ); | |
| if ( json.normalScale !== undefined ) { | |
| var normalScale = json.normalScale; | |
| if ( Array.isArray( normalScale ) === false ) { | |
| // Blender exporter used to export a scalar. See #7459 | |
| normalScale = [ normalScale, normalScale ]; | |
| } | |
| material.normalScale = new THREE.Vector2().fromArray( normalScale ); | |
| } | |
| if ( json.displacementMap !== undefined ) material.displacementMap = this.getTexture( json.displacementMap ); | |
| if ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale; | |
| if ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias; | |
| if ( json.roughnessMap !== undefined ) material.roughnessMap = this.getTexture( json.roughnessMap ); | |
| if ( json.metalnessMap !== undefined ) material.metalnessMap = this.getTexture( json.metalnessMap ); | |
| if ( json.emissiveMap !== undefined ) material.emissiveMap = this.getTexture( json.emissiveMap ); | |
| if ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity; | |
| if ( json.specularMap !== undefined ) material.specularMap = this.getTexture( json.specularMap ); | |
| if ( json.envMap !== undefined ) { | |
| material.envMap = this.getTexture( json.envMap ); | |
| material.combine = THREE.MultiplyOperation; | |
| } | |
| if ( json.reflectivity ) material.reflectivity = json.reflectivity; | |
| if ( json.lightMap !== undefined ) material.lightMap = this.getTexture( json.lightMap ); | |
| if ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity; | |
| if ( json.aoMap !== undefined ) material.aoMap = this.getTexture( json.aoMap ); | |
| if ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity; | |
| // MultiMaterial | |
| if ( json.materials !== undefined ) { | |
| for ( var i = 0, l = json.materials.length; i < l; i ++ ) { | |
| material.materials.push( this.parse( json.materials[ i ] ) ); | |
| } | |
| } | |
| return material; | |
| } | |
| }; | |
| // File:src/loaders/ObjectLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.ObjectLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| this.texturePath = ''; | |
| }; | |
| THREE.ObjectLoader.prototype = { | |
| constructor: THREE.ObjectLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| if ( this.texturePath === '' ) { | |
| this.texturePath = url.substring( 0, url.lastIndexOf( '/' ) + 1 ); | |
| } | |
| var scope = this; | |
| var loader = new THREE.XHRLoader( scope.manager ); | |
| loader.load( url, function ( text ) { | |
| scope.parse( JSON.parse( text ), onLoad ); | |
| }, onProgress, onError ); | |
| }, | |
| setTexturePath: function ( value ) { | |
| this.texturePath = value; | |
| }, | |
| setCrossOrigin: function ( value ) { | |
| this.crossOrigin = value; | |
| }, | |
| parse: function ( json, onLoad ) { | |
| var geometries = this.parseGeometries( json.geometries ); | |
| var images = this.parseImages( json.images, function () { | |
| if ( onLoad !== undefined ) onLoad( object ); | |
| } ); | |
| var textures = this.parseTextures( json.textures, images ); | |
| var materials = this.parseMaterials( json.materials, textures ); | |
| var object = this.parseObject( json.object, geometries, materials ); | |
| if ( json.animations ) { | |
| object.animations = this.parseAnimations( json.animations ); | |
| } | |
| if ( json.images === undefined || json.images.length === 0 ) { | |
| if ( onLoad !== undefined ) onLoad( object ); | |
| } | |
| return object; | |
| }, | |
| parseGeometries: function ( json ) { | |
| var geometries = {}; | |
| if ( json !== undefined ) { | |
| var geometryLoader = new THREE.JSONLoader(); | |
| var bufferGeometryLoader = new THREE.BufferGeometryLoader(); | |
| for ( var i = 0, l = json.length; i < l; i ++ ) { | |
| var geometry; | |
| var data = json[ i ]; | |
| switch ( data.type ) { | |
| case 'PlaneGeometry': | |
| case 'PlaneBufferGeometry': | |
| geometry = new THREE[ data.type ]( | |
| data.width, | |
| data.height, | |
| data.widthSegments, | |
| data.heightSegments | |
| ); | |
| break; | |
| case 'BoxGeometry': | |
| case 'CubeGeometry': // backwards compatible | |
| geometry = new THREE.BoxGeometry( | |
| data.width, | |
| data.height, | |
| data.depth, | |
| data.widthSegments, | |
| data.heightSegments, | |
| data.depthSegments | |
| ); | |
| break; | |
| case 'CircleBufferGeometry': | |
| geometry = new THREE.CircleBufferGeometry( | |
| data.radius, | |
| data.segments, | |
| data.thetaStart, | |
| data.thetaLength | |
| ); | |
| break; | |
| case 'CircleGeometry': | |
| geometry = new THREE.CircleGeometry( | |
| data.radius, | |
| data.segments, | |
| data.thetaStart, | |
| data.thetaLength | |
| ); | |
| break; | |
| case 'CylinderGeometry': | |
| geometry = new THREE.CylinderGeometry( | |
| data.radiusTop, | |
| data.radiusBottom, | |
| data.height, | |
| data.radialSegments, | |
| data.heightSegments, | |
| data.openEnded, | |
| data.thetaStart, | |
| data.thetaLength | |
| ); | |
| break; | |
| case 'SphereGeometry': | |
| geometry = new THREE.SphereGeometry( | |
| data.radius, | |
| data.widthSegments, | |
| data.heightSegments, | |
| data.phiStart, | |
| data.phiLength, | |
| data.thetaStart, | |
| data.thetaLength | |
| ); | |
| break; | |
| case 'SphereBufferGeometry': | |
| geometry = new THREE.SphereBufferGeometry( | |
| data.radius, | |
| data.widthSegments, | |
| data.heightSegments, | |
| data.phiStart, | |
| data.phiLength, | |
| data.thetaStart, | |
| data.thetaLength | |
| ); | |
| break; | |
| case 'DodecahedronGeometry': | |
| geometry = new THREE.DodecahedronGeometry( | |
| data.radius, | |
| data.detail | |
| ); | |
| break; | |
| case 'IcosahedronGeometry': | |
| geometry = new THREE.IcosahedronGeometry( | |
| data.radius, | |
| data.detail | |
| ); | |
| break; | |
| case 'OctahedronGeometry': | |
| geometry = new THREE.OctahedronGeometry( | |
| data.radius, | |
| data.detail | |
| ); | |
| break; | |
| case 'TetrahedronGeometry': | |
| geometry = new THREE.TetrahedronGeometry( | |
| data.radius, | |
| data.detail | |
| ); | |
| break; | |
| case 'RingGeometry': | |
| geometry = new THREE.RingGeometry( | |
| data.innerRadius, | |
| data.outerRadius, | |
| data.thetaSegments, | |
| data.phiSegments, | |
| data.thetaStart, | |
| data.thetaLength | |
| ); | |
| break; | |
| case 'TorusGeometry': | |
| geometry = new THREE.TorusGeometry( | |
| data.radius, | |
| data.tube, | |
| data.radialSegments, | |
| data.tubularSegments, | |
| data.arc | |
| ); | |
| break; | |
| case 'TorusKnotGeometry': | |
| geometry = new THREE.TorusKnotGeometry( | |
| data.radius, | |
| data.tube, | |
| data.radialSegments, | |
| data.tubularSegments, | |
| data.p, | |
| data.q, | |
| data.heightScale | |
| ); | |
| break; | |
| case 'LatheGeometry': | |
| geometry = new THREE.LatheGeometry( | |
| data.points, | |
| data.segments, | |
| data.phiStart, | |
| data.phiLength | |
| ); | |
| break; | |
| case 'BufferGeometry': | |
| geometry = bufferGeometryLoader.parse( data ); | |
| break; | |
| case 'Geometry': | |
| geometry = geometryLoader.parse( data.data, this.texturePath ).geometry; | |
| break; | |
| default: | |
| console.warn( 'THREE.ObjectLoader: Unsupported geometry type "' + data.type + '"' ); | |
| continue; | |
| } | |
| geometry.uuid = data.uuid; | |
| if ( data.name !== undefined ) geometry.name = data.name; | |
| geometries[ data.uuid ] = geometry; | |
| } | |
| } | |
| return geometries; | |
| }, | |
| parseMaterials: function ( json, textures ) { | |
| var materials = {}; | |
| if ( json !== undefined ) { | |
| var loader = new THREE.MaterialLoader(); | |
| loader.setTextures( textures ); | |
| for ( var i = 0, l = json.length; i < l; i ++ ) { | |
| var material = loader.parse( json[ i ] ); | |
| materials[ material.uuid ] = material; | |
| } | |
| } | |
| return materials; | |
| }, | |
| parseAnimations: function ( json ) { | |
| var animations = []; | |
| for ( var i = 0; i < json.length; i ++ ) { | |
| var clip = THREE.AnimationClip.parse( json[ i ] ); | |
| animations.push( clip ); | |
| } | |
| return animations; | |
| }, | |
| parseImages: function ( json, onLoad ) { | |
| var scope = this; | |
| var images = {}; | |
| function loadImage( url ) { | |
| scope.manager.itemStart( url ); | |
| return loader.load( url, function () { | |
| scope.manager.itemEnd( url ); | |
| } ); | |
| } | |
| if ( json !== undefined && json.length > 0 ) { | |
| var manager = new THREE.LoadingManager( onLoad ); | |
| var loader = new THREE.ImageLoader( manager ); | |
| loader.setCrossOrigin( this.crossOrigin ); | |
| for ( var i = 0, l = json.length; i < l; i ++ ) { | |
| var image = json[ i ]; | |
| var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( image.url ) ? image.url : scope.texturePath + image.url; | |
| images[ image.uuid ] = loadImage( path ); | |
| } | |
| } | |
| return images; | |
| }, | |
| parseTextures: function ( json, images ) { | |
| function parseConstant( value ) { | |
| if ( typeof( value ) === 'number' ) return value; | |
| console.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value ); | |
| return THREE[ value ]; | |
| } | |
| var textures = {}; | |
| if ( json !== undefined ) { | |
| for ( var i = 0, l = json.length; i < l; i ++ ) { | |
| var data = json[ i ]; | |
| if ( data.image === undefined ) { | |
| console.warn( 'THREE.ObjectLoader: No "image" specified for', data.uuid ); | |
| } | |
| if ( images[ data.image ] === undefined ) { | |
| console.warn( 'THREE.ObjectLoader: Undefined image', data.image ); | |
| } | |
| var texture = new THREE.Texture( images[ data.image ] ); | |
| texture.needsUpdate = true; | |
| texture.uuid = data.uuid; | |
| if ( data.name !== undefined ) texture.name = data.name; | |
| if ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping ); | |
| if ( data.offset !== undefined ) texture.offset = new THREE.Vector2( data.offset[ 0 ], data.offset[ 1 ] ); | |
| if ( data.repeat !== undefined ) texture.repeat = new THREE.Vector2( data.repeat[ 0 ], data.repeat[ 1 ] ); | |
| if ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter ); | |
| if ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter ); | |
| if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy; | |
| if ( Array.isArray( data.wrap ) ) { | |
| texture.wrapS = parseConstant( data.wrap[ 0 ] ); | |
| texture.wrapT = parseConstant( data.wrap[ 1 ] ); | |
| } | |
| textures[ data.uuid ] = texture; | |
| } | |
| } | |
| return textures; | |
| }, | |
| parseObject: function () { | |
| var matrix = new THREE.Matrix4(); | |
| return function ( data, geometries, materials ) { | |
| var object; | |
| function getGeometry( name ) { | |
| if ( geometries[ name ] === undefined ) { | |
| console.warn( 'THREE.ObjectLoader: Undefined geometry', name ); | |
| } | |
| return geometries[ name ]; | |
| } | |
| function getMaterial( name ) { | |
| if ( name === undefined ) return undefined; | |
| if ( materials[ name ] === undefined ) { | |
| console.warn( 'THREE.ObjectLoader: Undefined material', name ); | |
| } | |
| return materials[ name ]; | |
| } | |
| switch ( data.type ) { | |
| case 'Scene': | |
| object = new THREE.Scene(); | |
| break; | |
| case 'PerspectiveCamera': | |
| object = new THREE.PerspectiveCamera( data.fov, data.aspect, data.near, data.far ); | |
| break; | |
| case 'OrthographicCamera': | |
| object = new THREE.OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far ); | |
| break; | |
| case 'AmbientLight': | |
| object = new THREE.AmbientLight( data.color, data.intensity ); | |
| break; | |
| case 'DirectionalLight': | |
| object = new THREE.DirectionalLight( data.color, data.intensity ); | |
| break; | |
| case 'PointLight': | |
| object = new THREE.PointLight( data.color, data.intensity, data.distance, data.decay ); | |
| break; | |
| case 'SpotLight': | |
| object = new THREE.SpotLight( data.color, data.intensity, data.distance, data.angle, data.exponent, data.decay ); | |
| break; | |
| case 'HemisphereLight': | |
| object = new THREE.HemisphereLight( data.color, data.groundColor, data.intensity ); | |
| break; | |
| case 'Mesh': | |
| var geometry = getGeometry( data.geometry ); | |
| var material = getMaterial( data.material ); | |
| if ( geometry.bones && geometry.bones.length > 0 ) { | |
| object = new THREE.SkinnedMesh( geometry, material ); | |
| } else { | |
| object = new THREE.Mesh( geometry, material ); | |
| } | |
| break; | |
| case 'LOD': | |
| object = new THREE.LOD(); | |
| break; | |
| case 'Line': | |
| object = new THREE.Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode ); | |
| break; | |
| case 'PointCloud': | |
| case 'Points': | |
| object = new THREE.Points( getGeometry( data.geometry ), getMaterial( data.material ) ); | |
| break; | |
| case 'Sprite': | |
| object = new THREE.Sprite( getMaterial( data.material ) ); | |
| break; | |
| case 'Group': | |
| object = new THREE.Group(); | |
| break; | |
| default: | |
| object = new THREE.Object3D(); | |
| } | |
| object.uuid = data.uuid; | |
| if ( data.name !== undefined ) object.name = data.name; | |
| if ( data.matrix !== undefined ) { | |
| matrix.fromArray( data.matrix ); | |
| matrix.decompose( object.position, object.quaternion, object.scale ); | |
| } else { | |
| if ( data.position !== undefined ) object.position.fromArray( data.position ); | |
| if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation ); | |
| if ( data.scale !== undefined ) object.scale.fromArray( data.scale ); | |
| } | |
| if ( data.castShadow !== undefined ) object.castShadow = data.castShadow; | |
| if ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow; | |
| if ( data.visible !== undefined ) object.visible = data.visible; | |
| if ( data.userData !== undefined ) object.userData = data.userData; | |
| if ( data.children !== undefined ) { | |
| for ( var child in data.children ) { | |
| object.add( this.parseObject( data.children[ child ], geometries, materials ) ); | |
| } | |
| } | |
| if ( data.type === 'LOD' ) { | |
| var levels = data.levels; | |
| for ( var l = 0; l < levels.length; l ++ ) { | |
| var level = levels[ l ]; | |
| var child = object.getObjectByProperty( 'uuid', level.object ); | |
| if ( child !== undefined ) { | |
| object.addLevel( child, level.distance ); | |
| } | |
| } | |
| } | |
| return object; | |
| } | |
| }() | |
| }; | |
| // File:src/loaders/TextureLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.TextureLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| }; | |
| THREE.TextureLoader.prototype = { | |
| constructor: THREE.TextureLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var texture = new THREE.Texture(); | |
| var loader = new THREE.ImageLoader( this.manager ); | |
| loader.setCrossOrigin( this.crossOrigin ); | |
| loader.setPath( this.path ); | |
| loader.load( url, function ( image ) { | |
| texture.image = image; | |
| texture.needsUpdate = true; | |
| if ( onLoad !== undefined ) { | |
| onLoad( texture ); | |
| } | |
| }, onProgress, onError ); | |
| return texture; | |
| }, | |
| setCrossOrigin: function ( value ) { | |
| this.crossOrigin = value; | |
| }, | |
| setPath: function ( value ) { | |
| this.path = value; | |
| } | |
| }; | |
| // File:src/loaders/CubeTextureLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.CubeTextureLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| }; | |
| THREE.CubeTextureLoader.prototype = { | |
| constructor: THREE.CubeTextureLoader, | |
| load: function ( urls, onLoad, onProgress, onError ) { | |
| var texture = new THREE.CubeTexture( [] ); | |
| var loader = new THREE.ImageLoader( this.manager ); | |
| loader.setCrossOrigin( this.crossOrigin ); | |
| loader.setPath( this.path ); | |
| var loaded = 0; | |
| function loadTexture( i ) { | |
| loader.load( urls[ i ], function ( image ) { | |
| texture.images[ i ] = image; | |
| loaded ++; | |
| if ( loaded === 6 ) { | |
| texture.needsUpdate = true; | |
| if ( onLoad ) onLoad( texture ); | |
| } | |
| }, undefined, onError ); | |
| } | |
| for ( var i = 0; i < urls.length; ++ i ) { | |
| loadTexture( i ); | |
| } | |
| return texture; | |
| }, | |
| setCrossOrigin: function ( value ) { | |
| this.crossOrigin = value; | |
| }, | |
| setPath: function ( value ) { | |
| this.path = value; | |
| } | |
| }; | |
| // File:src/loaders/BinaryTextureLoader.js | |
| /** | |
| * @author Nikos M. / https://github.com/foo123/ | |
| * | |
| * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...) | |
| */ | |
| THREE.DataTextureLoader = THREE.BinaryTextureLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| // override in sub classes | |
| this._parser = null; | |
| }; | |
| THREE.BinaryTextureLoader.prototype = { | |
| constructor: THREE.BinaryTextureLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var texture = new THREE.DataTexture(); | |
| var loader = new THREE.XHRLoader( this.manager ); | |
| loader.setResponseType( 'arraybuffer' ); | |
| loader.load( url, function ( buffer ) { | |
| var texData = scope._parser( buffer ); | |
| if ( ! texData ) return; | |
| if ( undefined !== texData.image ) { | |
| texture.image = texData.image; | |
| } else if ( undefined !== texData.data ) { | |
| texture.image.width = texData.width; | |
| texture.image.height = texData.height; | |
| texture.image.data = texData.data; | |
| } | |
| texture.wrapS = undefined !== texData.wrapS ? texData.wrapS : THREE.ClampToEdgeWrapping; | |
| texture.wrapT = undefined !== texData.wrapT ? texData.wrapT : THREE.ClampToEdgeWrapping; | |
| texture.magFilter = undefined !== texData.magFilter ? texData.magFilter : THREE.LinearFilter; | |
| texture.minFilter = undefined !== texData.minFilter ? texData.minFilter : THREE.LinearMipMapLinearFilter; | |
| texture.anisotropy = undefined !== texData.anisotropy ? texData.anisotropy : 1; | |
| if ( undefined !== texData.format ) { | |
| texture.format = texData.format; | |
| } | |
| if ( undefined !== texData.type ) { | |
| texture.type = texData.type; | |
| } | |
| if ( undefined !== texData.mipmaps ) { | |
| texture.mipmaps = texData.mipmaps; | |
| } | |
| if ( 1 === texData.mipmapCount ) { | |
| texture.minFilter = THREE.LinearFilter; | |
| } | |
| texture.needsUpdate = true; | |
| if ( onLoad ) onLoad( texture, texData ); | |
| }, onProgress, onError ); | |
| return texture; | |
| } | |
| }; | |
| // File:src/loaders/CompressedTextureLoader.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * | |
| * Abstract Base class to block based textures loader (dds, pvr, ...) | |
| */ | |
| THREE.CompressedTextureLoader = function ( manager ) { | |
| this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager; | |
| // override in sub classes | |
| this._parser = null; | |
| }; | |
| THREE.CompressedTextureLoader.prototype = { | |
| constructor: THREE.CompressedTextureLoader, | |
| load: function ( url, onLoad, onProgress, onError ) { | |
| var scope = this; | |
| var images = []; | |
| var texture = new THREE.CompressedTexture(); | |
| texture.image = images; | |
| var loader = new THREE.XHRLoader( this.manager ); | |
| loader.setPath( this.path ); | |
| loader.setResponseType( 'arraybuffer' ); | |
| function loadTexture( i ) { | |
| loader.load( url[ i ], function ( buffer ) { | |
| var texDatas = scope._parser( buffer, true ); | |
| images[ i ] = { | |
| width: texDatas.width, | |
| height: texDatas.height, | |
| format: texDatas.format, | |
| mipmaps: texDatas.mipmaps | |
| }; | |
| loaded += 1; | |
| if ( loaded === 6 ) { | |
| if ( texDatas.mipmapCount === 1 ) | |
| texture.minFilter = THREE.LinearFilter; | |
| texture.format = texDatas.format; | |
| texture.needsUpdate = true; | |
| if ( onLoad ) onLoad( texture ); | |
| } | |
| }, onProgress, onError ); | |
| } | |
| if ( Array.isArray( url ) ) { | |
| var loaded = 0; | |
| for ( var i = 0, il = url.length; i < il; ++ i ) { | |
| loadTexture( i ); | |
| } | |
| } else { | |
| // compressed cubemap texture stored in a single DDS file | |
| loader.load( url, function ( buffer ) { | |
| var texDatas = scope._parser( buffer, true ); | |
| if ( texDatas.isCubemap ) { | |
| var faces = texDatas.mipmaps.length / texDatas.mipmapCount; | |
| for ( var f = 0; f < faces; f ++ ) { | |
| images[ f ] = { mipmaps : [] }; | |
| for ( var i = 0; i < texDatas.mipmapCount; i ++ ) { | |
| images[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] ); | |
| images[ f ].format = texDatas.format; | |
| images[ f ].width = texDatas.width; | |
| images[ f ].height = texDatas.height; | |
| } | |
| } | |
| } else { | |
| texture.image.width = texDatas.width; | |
| texture.image.height = texDatas.height; | |
| texture.mipmaps = texDatas.mipmaps; | |
| } | |
| if ( texDatas.mipmapCount === 1 ) { | |
| texture.minFilter = THREE.LinearFilter; | |
| } | |
| texture.format = texDatas.format; | |
| texture.needsUpdate = true; | |
| if ( onLoad ) onLoad( texture ); | |
| }, onProgress, onError ); | |
| } | |
| return texture; | |
| }, | |
| setPath: function ( value ) { | |
| this.path = value; | |
| } | |
| }; | |
| // File:src/materials/Material.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Material = function () { | |
| Object.defineProperty( this, 'id', { value: THREE.MaterialIdCount ++ } ); | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.name = ''; | |
| this.type = 'Material'; | |
| this.side = THREE.FrontSide; | |
| this.opacity = 1; | |
| this.transparent = false; | |
| this.blending = THREE.NormalBlending; | |
| this.blendSrc = THREE.SrcAlphaFactor; | |
| this.blendDst = THREE.OneMinusSrcAlphaFactor; | |
| this.blendEquation = THREE.AddEquation; | |
| this.blendSrcAlpha = null; | |
| this.blendDstAlpha = null; | |
| this.blendEquationAlpha = null; | |
| this.depthFunc = THREE.LessEqualDepth; | |
| this.depthTest = true; | |
| this.depthWrite = true; | |
| this.colorWrite = true; | |
| this.precision = null; // override the renderer's default precision for this material | |
| this.polygonOffset = false; | |
| this.polygonOffsetFactor = 0; | |
| this.polygonOffsetUnits = 0; | |
| this.alphaTest = 0; | |
| this.overdraw = 0; // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer | |
| this.visible = true; | |
| this._needsUpdate = true; | |
| }; | |
| THREE.Material.prototype = { | |
| constructor: THREE.Material, | |
| get needsUpdate () { | |
| return this._needsUpdate; | |
| }, | |
| set needsUpdate ( value ) { | |
| if ( value === true ) this.update(); | |
| this._needsUpdate = value; | |
| }, | |
| setValues: function ( values ) { | |
| if ( values === undefined ) return; | |
| for ( var key in values ) { | |
| var newValue = values[ key ]; | |
| if ( newValue === undefined ) { | |
| console.warn( "THREE.Material: '" + key + "' parameter is undefined." ); | |
| continue; | |
| } | |
| var currentValue = this[ key ]; | |
| if ( currentValue === undefined ) { | |
| console.warn( "THREE." + this.type + ": '" + key + "' is not a property of this material." ); | |
| continue; | |
| } | |
| if ( currentValue instanceof THREE.Color ) { | |
| currentValue.set( newValue ); | |
| } else if ( currentValue instanceof THREE.Vector3 && newValue instanceof THREE.Vector3 ) { | |
| currentValue.copy( newValue ); | |
| } else if ( key === 'overdraw' ) { | |
| // ensure overdraw is backwards-compatible with legacy boolean type | |
| this[ key ] = Number( newValue ); | |
| } else { | |
| this[ key ] = newValue; | |
| } | |
| } | |
| }, | |
| toJSON: function ( meta ) { | |
| var isRoot = meta === undefined; | |
| if ( isRoot ) { | |
| meta = { | |
| textures: {}, | |
| images: {} | |
| }; | |
| } | |
| var data = { | |
| metadata: { | |
| version: 4.4, | |
| type: 'Material', | |
| generator: 'Material.toJSON' | |
| } | |
| }; | |
| // standard Material serialization | |
| data.uuid = this.uuid; | |
| data.type = this.type; | |
| if ( this.name !== '' ) data.name = this.name; | |
| if ( this.color instanceof THREE.Color ) data.color = this.color.getHex(); | |
| if ( this.roughness !== 0.5 ) data.roughness = this.roughness; | |
| if ( this.metalness !== 0.5 ) data.metalness = this.metalness; | |
| if ( this.emissive instanceof THREE.Color ) data.emissive = this.emissive.getHex(); | |
| if ( this.specular instanceof THREE.Color ) data.specular = this.specular.getHex(); | |
| if ( this.shininess !== undefined ) data.shininess = this.shininess; | |
| if ( this.map instanceof THREE.Texture ) data.map = this.map.toJSON( meta ).uuid; | |
| if ( this.alphaMap instanceof THREE.Texture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid; | |
| if ( this.lightMap instanceof THREE.Texture ) data.lightMap = this.lightMap.toJSON( meta ).uuid; | |
| if ( this.bumpMap instanceof THREE.Texture ) { | |
| data.bumpMap = this.bumpMap.toJSON( meta ).uuid; | |
| data.bumpScale = this.bumpScale; | |
| } | |
| if ( this.normalMap instanceof THREE.Texture ) { | |
| data.normalMap = this.normalMap.toJSON( meta ).uuid; | |
| data.normalScale = this.normalScale.toArray(); | |
| } | |
| if ( this.displacementMap instanceof THREE.Texture ) { | |
| data.displacementMap = this.displacementMap.toJSON( meta ).uuid; | |
| data.displacementScale = this.displacementScale; | |
| data.displacementBias = this.displacementBias; | |
| } | |
| if ( this.roughnessMap instanceof THREE.Texture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid; | |
| if ( this.metalnessMap instanceof THREE.Texture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid; | |
| if ( this.emissiveMap instanceof THREE.Texture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid; | |
| if ( this.specularMap instanceof THREE.Texture ) data.specularMap = this.specularMap.toJSON( meta ).uuid; | |
| if ( this.envMap instanceof THREE.Texture ) { | |
| data.envMap = this.envMap.toJSON( meta ).uuid; | |
| data.reflectivity = this.reflectivity; // Scale behind envMap | |
| } | |
| if ( this.size !== undefined ) data.size = this.size; | |
| if ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation; | |
| if ( this.vertexColors !== undefined && this.vertexColors !== THREE.NoColors ) data.vertexColors = this.vertexColors; | |
| if ( this.shading !== undefined && this.shading !== THREE.SmoothShading ) data.shading = this.shading; | |
| if ( this.blending !== undefined && this.blending !== THREE.NormalBlending ) data.blending = this.blending; | |
| if ( this.side !== undefined && this.side !== THREE.FrontSide ) data.side = this.side; | |
| if ( this.opacity < 1 ) data.opacity = this.opacity; | |
| if ( this.transparent === true ) data.transparent = this.transparent; | |
| if ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest; | |
| if ( this.wireframe === true ) data.wireframe = this.wireframe; | |
| if ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth; | |
| // TODO: Copied from Object3D.toJSON | |
| function extractFromCache ( cache ) { | |
| var values = []; | |
| for ( var key in cache ) { | |
| var data = cache[ key ]; | |
| delete data.metadata; | |
| values.push( data ); | |
| } | |
| return values; | |
| } | |
| if ( isRoot ) { | |
| var textures = extractFromCache( meta.textures ); | |
| var images = extractFromCache( meta.images ); | |
| if ( textures.length > 0 ) data.textures = textures; | |
| if ( images.length > 0 ) data.images = images; | |
| } | |
| return data; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( source ) { | |
| this.name = source.name; | |
| this.side = source.side; | |
| this.opacity = source.opacity; | |
| this.transparent = source.transparent; | |
| this.blending = source.blending; | |
| this.blendSrc = source.blendSrc; | |
| this.blendDst = source.blendDst; | |
| this.blendEquation = source.blendEquation; | |
| this.blendSrcAlpha = source.blendSrcAlpha; | |
| this.blendDstAlpha = source.blendDstAlpha; | |
| this.blendEquationAlpha = source.blendEquationAlpha; | |
| this.depthFunc = source.depthFunc; | |
| this.depthTest = source.depthTest; | |
| this.depthWrite = source.depthWrite; | |
| this.colorWrite = source.colorWrite; | |
| this.precision = source.precision; | |
| this.polygonOffset = source.polygonOffset; | |
| this.polygonOffsetFactor = source.polygonOffsetFactor; | |
| this.polygonOffsetUnits = source.polygonOffsetUnits; | |
| this.alphaTest = source.alphaTest; | |
| this.overdraw = source.overdraw; | |
| this.visible = source.visible; | |
| return this; | |
| }, | |
| update: function () { | |
| this.dispatchEvent( { type: 'update' } ); | |
| }, | |
| dispose: function () { | |
| this.dispatchEvent( { type: 'dispose' } ); | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.Material.prototype ); | |
| THREE.MaterialIdCount = 0; | |
| // File:src/materials/LineBasicMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * opacity: <float>, | |
| * | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * linewidth: <float>, | |
| * linecap: "round", | |
| * linejoin: "round", | |
| * | |
| * vertexColors: <bool> | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.LineBasicMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'LineBasicMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); | |
| this.linewidth = 1; | |
| this.linecap = 'round'; | |
| this.linejoin = 'round'; | |
| this.vertexColors = THREE.NoColors; | |
| this.fog = true; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.LineBasicMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.LineBasicMaterial.prototype.constructor = THREE.LineBasicMaterial; | |
| THREE.LineBasicMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.linewidth = source.linewidth; | |
| this.linecap = source.linecap; | |
| this.linejoin = source.linejoin; | |
| this.vertexColors = source.vertexColors; | |
| this.fog = source.fog; | |
| return this; | |
| }; | |
| // File:src/materials/LineDashedMaterial.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * opacity: <float>, | |
| * | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * linewidth: <float>, | |
| * | |
| * scale: <float>, | |
| * dashSize: <float>, | |
| * gapSize: <float>, | |
| * | |
| * vertexColors: THREE.NoColors / THREE.FaceColors / THREE.VertexColors | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.LineDashedMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'LineDashedMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); | |
| this.linewidth = 1; | |
| this.scale = 1; | |
| this.dashSize = 3; | |
| this.gapSize = 1; | |
| this.vertexColors = THREE.NoColors; | |
| this.fog = true; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.LineDashedMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.LineDashedMaterial.prototype.constructor = THREE.LineDashedMaterial; | |
| THREE.LineDashedMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.linewidth = source.linewidth; | |
| this.scale = source.scale; | |
| this.dashSize = source.dashSize; | |
| this.gapSize = source.gapSize; | |
| this.vertexColors = source.vertexColors; | |
| this.fog = source.fog; | |
| return this; | |
| }; | |
| // File:src/materials/MeshBasicMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * opacity: <float>, | |
| * map: new THREE.Texture( <Image> ), | |
| * | |
| * aoMap: new THREE.Texture( <Image> ), | |
| * aoMapIntensity: <float> | |
| * | |
| * specularMap: new THREE.Texture( <Image> ), | |
| * | |
| * alphaMap: new THREE.Texture( <Image> ), | |
| * | |
| * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ), | |
| * combine: THREE.Multiply, | |
| * reflectivity: <float>, | |
| * refractionRatio: <float>, | |
| * | |
| * shading: THREE.SmoothShading, | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * wireframe: <boolean>, | |
| * wireframeLinewidth: <float>, | |
| * | |
| * vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors, | |
| * | |
| * skinning: <bool>, | |
| * morphTargets: <bool>, | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.MeshBasicMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'MeshBasicMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); // emissive | |
| this.map = null; | |
| this.aoMap = null; | |
| this.aoMapIntensity = 1.0; | |
| this.specularMap = null; | |
| this.alphaMap = null; | |
| this.envMap = null; | |
| this.combine = THREE.MultiplyOperation; | |
| this.reflectivity = 1; | |
| this.refractionRatio = 0.98; | |
| this.fog = true; | |
| this.shading = THREE.SmoothShading; | |
| this.wireframe = false; | |
| this.wireframeLinewidth = 1; | |
| this.wireframeLinecap = 'round'; | |
| this.wireframeLinejoin = 'round'; | |
| this.vertexColors = THREE.NoColors; | |
| this.skinning = false; | |
| this.morphTargets = false; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.MeshBasicMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.MeshBasicMaterial.prototype.constructor = THREE.MeshBasicMaterial; | |
| THREE.MeshBasicMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.map = source.map; | |
| this.aoMap = source.aoMap; | |
| this.aoMapIntensity = source.aoMapIntensity; | |
| this.specularMap = source.specularMap; | |
| this.alphaMap = source.alphaMap; | |
| this.envMap = source.envMap; | |
| this.combine = source.combine; | |
| this.reflectivity = source.reflectivity; | |
| this.refractionRatio = source.refractionRatio; | |
| this.fog = source.fog; | |
| this.shading = source.shading; | |
| this.wireframe = source.wireframe; | |
| this.wireframeLinewidth = source.wireframeLinewidth; | |
| this.wireframeLinecap = source.wireframeLinecap; | |
| this.wireframeLinejoin = source.wireframeLinejoin; | |
| this.vertexColors = source.vertexColors; | |
| this.skinning = source.skinning; | |
| this.morphTargets = source.morphTargets; | |
| return this; | |
| }; | |
| // File:src/materials/MeshLambertMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * opacity: <float>, | |
| * | |
| * map: new THREE.Texture( <Image> ), | |
| * | |
| * lightMap: new THREE.Texture( <Image> ), | |
| * lightMapIntensity: <float> | |
| * | |
| * aoMap: new THREE.Texture( <Image> ), | |
| * aoMapIntensity: <float> | |
| * | |
| * emissive: <hex>, | |
| * emissiveIntensity: <float> | |
| * emissiveMap: new THREE.Texture( <Image> ), | |
| * | |
| * specularMap: new THREE.Texture( <Image> ), | |
| * | |
| * alphaMap: new THREE.Texture( <Image> ), | |
| * | |
| * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ), | |
| * combine: THREE.Multiply, | |
| * reflectivity: <float>, | |
| * refractionRatio: <float>, | |
| * | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * wireframe: <boolean>, | |
| * wireframeLinewidth: <float>, | |
| * | |
| * vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors, | |
| * | |
| * skinning: <bool>, | |
| * morphTargets: <bool>, | |
| * morphNormals: <bool>, | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.MeshLambertMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'MeshLambertMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); // diffuse | |
| this.map = null; | |
| this.lightMap = null; | |
| this.lightMapIntensity = 1.0; | |
| this.aoMap = null; | |
| this.aoMapIntensity = 1.0; | |
| this.emissive = new THREE.Color( 0x000000 ); | |
| this.emissiveIntensity = 1.0; | |
| this.emissiveMap = null; | |
| this.specularMap = null; | |
| this.alphaMap = null; | |
| this.envMap = null; | |
| this.combine = THREE.MultiplyOperation; | |
| this.reflectivity = 1; | |
| this.refractionRatio = 0.98; | |
| this.fog = true; | |
| this.wireframe = false; | |
| this.wireframeLinewidth = 1; | |
| this.wireframeLinecap = 'round'; | |
| this.wireframeLinejoin = 'round'; | |
| this.vertexColors = THREE.NoColors; | |
| this.skinning = false; | |
| this.morphTargets = false; | |
| this.morphNormals = false; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.MeshLambertMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.MeshLambertMaterial.prototype.constructor = THREE.MeshLambertMaterial; | |
| THREE.MeshLambertMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.map = source.map; | |
| this.lightMap = source.lightMap; | |
| this.lightMapIntensity = source.lightMapIntensity; | |
| this.aoMap = source.aoMap; | |
| this.aoMapIntensity = source.aoMapIntensity; | |
| this.emissive.copy( source.emissive ); | |
| this.emissiveMap = source.emissiveMap; | |
| this.emissiveIntensity = source.emissiveIntensity; | |
| this.specularMap = source.specularMap; | |
| this.alphaMap = source.alphaMap; | |
| this.envMap = source.envMap; | |
| this.combine = source.combine; | |
| this.reflectivity = source.reflectivity; | |
| this.refractionRatio = source.refractionRatio; | |
| this.fog = source.fog; | |
| this.wireframe = source.wireframe; | |
| this.wireframeLinewidth = source.wireframeLinewidth; | |
| this.wireframeLinecap = source.wireframeLinecap; | |
| this.wireframeLinejoin = source.wireframeLinejoin; | |
| this.vertexColors = source.vertexColors; | |
| this.skinning = source.skinning; | |
| this.morphTargets = source.morphTargets; | |
| this.morphNormals = source.morphNormals; | |
| return this; | |
| }; | |
| // File:src/materials/MeshPhongMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * specular: <hex>, | |
| * shininess: <float>, | |
| * opacity: <float>, | |
| * | |
| * map: new THREE.Texture( <Image> ), | |
| * | |
| * lightMap: new THREE.Texture( <Image> ), | |
| * lightMapIntensity: <float> | |
| * | |
| * aoMap: new THREE.Texture( <Image> ), | |
| * aoMapIntensity: <float> | |
| * | |
| * emissive: <hex>, | |
| * emissiveIntensity: <float> | |
| * emissiveMap: new THREE.Texture( <Image> ), | |
| * | |
| * bumpMap: new THREE.Texture( <Image> ), | |
| * bumpScale: <float>, | |
| * | |
| * normalMap: new THREE.Texture( <Image> ), | |
| * normalScale: <Vector2>, | |
| * | |
| * displacementMap: new THREE.Texture( <Image> ), | |
| * displacementScale: <float>, | |
| * displacementBias: <float>, | |
| * | |
| * specularMap: new THREE.Texture( <Image> ), | |
| * | |
| * alphaMap: new THREE.Texture( <Image> ), | |
| * | |
| * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ), | |
| * combine: THREE.Multiply, | |
| * reflectivity: <float>, | |
| * refractionRatio: <float>, | |
| * | |
| * shading: THREE.SmoothShading, | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * wireframe: <boolean>, | |
| * wireframeLinewidth: <float>, | |
| * | |
| * vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors, | |
| * | |
| * skinning: <bool>, | |
| * morphTargets: <bool>, | |
| * morphNormals: <bool>, | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.MeshPhongMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'MeshPhongMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); // diffuse | |
| this.specular = new THREE.Color( 0x111111 ); | |
| this.shininess = 30; | |
| this.map = null; | |
| this.lightMap = null; | |
| this.lightMapIntensity = 1.0; | |
| this.aoMap = null; | |
| this.aoMapIntensity = 1.0; | |
| this.emissive = new THREE.Color( 0x000000 ); | |
| this.emissiveIntensity = 1.0; | |
| this.emissiveMap = null; | |
| this.bumpMap = null; | |
| this.bumpScale = 1; | |
| this.normalMap = null; | |
| this.normalScale = new THREE.Vector2( 1, 1 ); | |
| this.displacementMap = null; | |
| this.displacementScale = 1; | |
| this.displacementBias = 0; | |
| this.specularMap = null; | |
| this.alphaMap = null; | |
| this.envMap = null; | |
| this.combine = THREE.MultiplyOperation; | |
| this.reflectivity = 1; | |
| this.refractionRatio = 0.98; | |
| this.fog = true; | |
| this.shading = THREE.SmoothShading; | |
| this.wireframe = false; | |
| this.wireframeLinewidth = 1; | |
| this.wireframeLinecap = 'round'; | |
| this.wireframeLinejoin = 'round'; | |
| this.vertexColors = THREE.NoColors; | |
| this.skinning = false; | |
| this.morphTargets = false; | |
| this.morphNormals = false; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.MeshPhongMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.MeshPhongMaterial.prototype.constructor = THREE.MeshPhongMaterial; | |
| THREE.MeshPhongMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.specular.copy( source.specular ); | |
| this.shininess = source.shininess; | |
| this.map = source.map; | |
| this.lightMap = source.lightMap; | |
| this.lightMapIntensity = source.lightMapIntensity; | |
| this.aoMap = source.aoMap; | |
| this.aoMapIntensity = source.aoMapIntensity; | |
| this.emissive.copy( source.emissive ); | |
| this.emissiveMap = source.emissiveMap; | |
| this.emissiveIntensity = source.emissiveIntensity; | |
| this.bumpMap = source.bumpMap; | |
| this.bumpScale = source.bumpScale; | |
| this.normalMap = source.normalMap; | |
| this.normalScale.copy( source.normalScale ); | |
| this.displacementMap = source.displacementMap; | |
| this.displacementScale = source.displacementScale; | |
| this.displacementBias = source.displacementBias; | |
| this.specularMap = source.specularMap; | |
| this.alphaMap = source.alphaMap; | |
| this.envMap = source.envMap; | |
| this.combine = source.combine; | |
| this.reflectivity = source.reflectivity; | |
| this.refractionRatio = source.refractionRatio; | |
| this.fog = source.fog; | |
| this.shading = source.shading; | |
| this.wireframe = source.wireframe; | |
| this.wireframeLinewidth = source.wireframeLinewidth; | |
| this.wireframeLinecap = source.wireframeLinecap; | |
| this.wireframeLinejoin = source.wireframeLinejoin; | |
| this.vertexColors = source.vertexColors; | |
| this.skinning = source.skinning; | |
| this.morphTargets = source.morphTargets; | |
| this.morphNormals = source.morphNormals; | |
| return this; | |
| }; | |
| // File:src/materials/MeshStandardMaterial.js | |
| /** | |
| * @author WestLangley / http://github.com/WestLangley | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * roughness: <float>, | |
| * metalness: <float>, | |
| * opacity: <float>, | |
| * | |
| * map: new THREE.Texture( <Image> ), | |
| * | |
| * lightMap: new THREE.Texture( <Image> ), | |
| * lightMapIntensity: <float> | |
| * | |
| * aoMap: new THREE.Texture( <Image> ), | |
| * aoMapIntensity: <float> | |
| * | |
| * emissive: <hex>, | |
| * emissiveIntensity: <float> | |
| * emissiveMap: new THREE.Texture( <Image> ), | |
| * | |
| * bumpMap: new THREE.Texture( <Image> ), | |
| * bumpScale: <float>, | |
| * | |
| * normalMap: new THREE.Texture( <Image> ), | |
| * normalScale: <Vector2>, | |
| * | |
| * displacementMap: new THREE.Texture( <Image> ), | |
| * displacementScale: <float>, | |
| * displacementBias: <float>, | |
| * | |
| * roughnessMap: new THREE.Texture( <Image> ), | |
| * | |
| * metalnessMap: new THREE.Texture( <Image> ), | |
| * | |
| * alphaMap: new THREE.Texture( <Image> ), | |
| * | |
| * envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ), | |
| * envMapIntensity: <float> | |
| * | |
| * refractionRatio: <float>, | |
| * | |
| * shading: THREE.SmoothShading, | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * wireframe: <boolean>, | |
| * wireframeLinewidth: <float>, | |
| * | |
| * vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors, | |
| * | |
| * skinning: <bool>, | |
| * morphTargets: <bool>, | |
| * morphNormals: <bool>, | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.MeshStandardMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'MeshStandardMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); // diffuse | |
| this.roughness = 0.5; | |
| this.metalness = 0.5; | |
| this.map = null; | |
| this.lightMap = null; | |
| this.lightMapIntensity = 1.0; | |
| this.aoMap = null; | |
| this.aoMapIntensity = 1.0; | |
| this.emissive = new THREE.Color( 0x000000 ); | |
| this.emissiveIntensity = 1.0; | |
| this.emissiveMap = null; | |
| this.bumpMap = null; | |
| this.bumpScale = 1; | |
| this.normalMap = null; | |
| this.normalScale = new THREE.Vector2( 1, 1 ); | |
| this.displacementMap = null; | |
| this.displacementScale = 1; | |
| this.displacementBias = 0; | |
| this.roughnessMap = null; | |
| this.metalnessMap = null; | |
| this.alphaMap = null; | |
| this.envMap = null; | |
| this.envMapIntensity = 1.0; | |
| this.refractionRatio = 0.98; | |
| this.fog = true; | |
| this.shading = THREE.SmoothShading; | |
| this.wireframe = false; | |
| this.wireframeLinewidth = 1; | |
| this.wireframeLinecap = 'round'; | |
| this.wireframeLinejoin = 'round'; | |
| this.vertexColors = THREE.NoColors; | |
| this.skinning = false; | |
| this.morphTargets = false; | |
| this.morphNormals = false; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.MeshStandardMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.MeshStandardMaterial.prototype.constructor = THREE.MeshStandardMaterial; | |
| THREE.MeshStandardMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.roughness = source.roughness; | |
| this.metalness = source.metalness; | |
| this.map = source.map; | |
| this.lightMap = source.lightMap; | |
| this.lightMapIntensity = source.lightMapIntensity; | |
| this.aoMap = source.aoMap; | |
| this.aoMapIntensity = source.aoMapIntensity; | |
| this.emissive.copy( source.emissive ); | |
| this.emissiveMap = source.emissiveMap; | |
| this.emissiveIntensity = source.emissiveIntensity; | |
| this.bumpMap = source.bumpMap; | |
| this.bumpScale = source.bumpScale; | |
| this.normalMap = source.normalMap; | |
| this.normalScale.copy( source.normalScale ); | |
| this.displacementMap = source.displacementMap; | |
| this.displacementScale = source.displacementScale; | |
| this.displacementBias = source.displacementBias; | |
| this.roughnessMap = source.roughnessMap; | |
| this.metalnessMap = source.metalnessMap; | |
| this.alphaMap = source.alphaMap; | |
| this.envMap = source.envMap; | |
| this.envMapIntensity = source.envMapIntensity; | |
| this.refractionRatio = source.refractionRatio; | |
| this.fog = source.fog; | |
| this.shading = source.shading; | |
| this.wireframe = source.wireframe; | |
| this.wireframeLinewidth = source.wireframeLinewidth; | |
| this.wireframeLinecap = source.wireframeLinecap; | |
| this.wireframeLinejoin = source.wireframeLinejoin; | |
| this.vertexColors = source.vertexColors; | |
| this.skinning = source.skinning; | |
| this.morphTargets = source.morphTargets; | |
| this.morphNormals = source.morphNormals; | |
| return this; | |
| }; | |
| // File:src/materials/MeshDepthMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * opacity: <float>, | |
| * | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * wireframe: <boolean>, | |
| * wireframeLinewidth: <float> | |
| * } | |
| */ | |
| THREE.MeshDepthMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'MeshDepthMaterial'; | |
| this.morphTargets = false; | |
| this.wireframe = false; | |
| this.wireframeLinewidth = 1; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.MeshDepthMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.MeshDepthMaterial.prototype.constructor = THREE.MeshDepthMaterial; | |
| THREE.MeshDepthMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.wireframe = source.wireframe; | |
| this.wireframeLinewidth = source.wireframeLinewidth; | |
| return this; | |
| }; | |
| // File:src/materials/MeshNormalMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * | |
| * parameters = { | |
| * opacity: <float>, | |
| * | |
| * shading: THREE.FlatShading, | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * wireframe: <boolean>, | |
| * wireframeLinewidth: <float> | |
| * } | |
| */ | |
| THREE.MeshNormalMaterial = function ( parameters ) { | |
| THREE.Material.call( this, parameters ); | |
| this.type = 'MeshNormalMaterial'; | |
| this.wireframe = false; | |
| this.wireframeLinewidth = 1; | |
| this.morphTargets = false; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.MeshNormalMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.MeshNormalMaterial.prototype.constructor = THREE.MeshNormalMaterial; | |
| THREE.MeshNormalMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.wireframe = source.wireframe; | |
| this.wireframeLinewidth = source.wireframeLinewidth; | |
| return this; | |
| }; | |
| // File:src/materials/MultiMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.MultiMaterial = function ( materials ) { | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.type = 'MultiMaterial'; | |
| this.materials = materials instanceof Array ? materials : []; | |
| this.visible = true; | |
| }; | |
| THREE.MultiMaterial.prototype = { | |
| constructor: THREE.MultiMaterial, | |
| toJSON: function ( meta ) { | |
| var output = { | |
| metadata: { | |
| version: 4.2, | |
| type: 'material', | |
| generator: 'MaterialExporter' | |
| }, | |
| uuid: this.uuid, | |
| type: this.type, | |
| materials: [] | |
| }; | |
| var materials = this.materials; | |
| for ( var i = 0, l = materials.length; i < l; i ++ ) { | |
| var material = materials[ i ].toJSON( meta ); | |
| delete material.metadata; | |
| output.materials.push( material ); | |
| } | |
| output.visible = this.visible; | |
| return output; | |
| }, | |
| clone: function () { | |
| var material = new this.constructor(); | |
| for ( var i = 0; i < this.materials.length; i ++ ) { | |
| material.materials.push( this.materials[ i ].clone() ); | |
| } | |
| material.visible = this.visible; | |
| return material; | |
| } | |
| }; | |
| // File:src/materials/PointsMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * opacity: <float>, | |
| * map: new THREE.Texture( <Image> ), | |
| * | |
| * size: <float>, | |
| * sizeAttenuation: <bool>, | |
| * | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * vertexColors: <bool>, | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.PointsMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'PointsMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); | |
| this.map = null; | |
| this.size = 1; | |
| this.sizeAttenuation = true; | |
| this.vertexColors = THREE.NoColors; | |
| this.fog = true; | |
| this.setValues( parameters ); | |
| }; | |
| THREE.PointsMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.PointsMaterial.prototype.constructor = THREE.PointsMaterial; | |
| THREE.PointsMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.map = source.map; | |
| this.size = source.size; | |
| this.sizeAttenuation = source.sizeAttenuation; | |
| this.vertexColors = source.vertexColors; | |
| this.fog = source.fog; | |
| return this; | |
| }; | |
| // File:src/materials/ShaderMaterial.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * defines: { "label" : "value" }, | |
| * uniforms: { "parameter1": { type: "f", value: 1.0 }, "parameter2": { type: "i" value2: 2 } }, | |
| * | |
| * fragmentShader: <string>, | |
| * vertexShader: <string>, | |
| * | |
| * shading: THREE.SmoothShading, | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * wireframe: <boolean>, | |
| * wireframeLinewidth: <float>, | |
| * | |
| * lights: <bool>, | |
| * | |
| * vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors, | |
| * | |
| * skinning: <bool>, | |
| * morphTargets: <bool>, | |
| * morphNormals: <bool>, | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.ShaderMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'ShaderMaterial'; | |
| this.defines = {}; | |
| this.uniforms = {}; | |
| this.vertexShader = 'void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}'; | |
| this.fragmentShader = 'void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}'; | |
| this.shading = THREE.SmoothShading; | |
| this.linewidth = 1; | |
| this.wireframe = false; | |
| this.wireframeLinewidth = 1; | |
| this.fog = false; // set to use scene fog | |
| this.lights = false; // set to use scene lights | |
| this.vertexColors = THREE.NoColors; // set to use "color" attribute stream | |
| this.skinning = false; // set to use skinning attribute streams | |
| this.morphTargets = false; // set to use morph targets | |
| this.morphNormals = false; // set to use morph normals | |
| this.extensions = { | |
| derivatives: false, // set to use derivatives | |
| fragDepth: false, // set to use fragment depth values | |
| drawBuffers: false, // set to use draw buffers | |
| shaderTextureLOD: false // set to use shader texture LOD | |
| }; | |
| // When rendered geometry doesn't include these attributes but the material does, | |
| // use these default values in WebGL. This avoids errors when buffer data is missing. | |
| this.defaultAttributeValues = { | |
| 'color': [ 1, 1, 1 ], | |
| 'uv': [ 0, 0 ], | |
| 'uv2': [ 0, 0 ] | |
| }; | |
| this.index0AttributeName = undefined; | |
| if ( parameters !== undefined ) { | |
| if ( parameters.attributes !== undefined ) { | |
| console.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' ); | |
| } | |
| this.setValues( parameters ); | |
| } | |
| }; | |
| THREE.ShaderMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.ShaderMaterial.prototype.constructor = THREE.ShaderMaterial; | |
| THREE.ShaderMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.fragmentShader = source.fragmentShader; | |
| this.vertexShader = source.vertexShader; | |
| this.uniforms = THREE.UniformsUtils.clone( source.uniforms ); | |
| this.defines = source.defines; | |
| this.shading = source.shading; | |
| this.wireframe = source.wireframe; | |
| this.wireframeLinewidth = source.wireframeLinewidth; | |
| this.fog = source.fog; | |
| this.lights = source.lights; | |
| this.vertexColors = source.vertexColors; | |
| this.skinning = source.skinning; | |
| this.morphTargets = source.morphTargets; | |
| this.morphNormals = source.morphNormals; | |
| this.extensions = source.extensions; | |
| return this; | |
| }; | |
| THREE.ShaderMaterial.prototype.toJSON = function ( meta ) { | |
| var data = THREE.Material.prototype.toJSON.call( this, meta ); | |
| data.uniforms = this.uniforms; | |
| data.vertexShader = this.vertexShader; | |
| data.fragmentShader = this.fragmentShader; | |
| return data; | |
| }; | |
| // File:src/materials/RawShaderMaterial.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.RawShaderMaterial = function ( parameters ) { | |
| THREE.ShaderMaterial.call( this, parameters ); | |
| this.type = 'RawShaderMaterial'; | |
| }; | |
| THREE.RawShaderMaterial.prototype = Object.create( THREE.ShaderMaterial.prototype ); | |
| THREE.RawShaderMaterial.prototype.constructor = THREE.RawShaderMaterial; | |
| // File:src/materials/SpriteMaterial.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| * | |
| * parameters = { | |
| * color: <hex>, | |
| * opacity: <float>, | |
| * map: new THREE.Texture( <Image> ), | |
| * | |
| * blending: THREE.NormalBlending, | |
| * depthTest: <bool>, | |
| * depthWrite: <bool>, | |
| * | |
| * uvOffset: new THREE.Vector2(), | |
| * uvScale: new THREE.Vector2(), | |
| * | |
| * fog: <bool> | |
| * } | |
| */ | |
| THREE.SpriteMaterial = function ( parameters ) { | |
| THREE.Material.call( this ); | |
| this.type = 'SpriteMaterial'; | |
| this.color = new THREE.Color( 0xffffff ); | |
| this.map = null; | |
| this.rotation = 0; | |
| this.fog = false; | |
| // set parameters | |
| this.setValues( parameters ); | |
| }; | |
| THREE.SpriteMaterial.prototype = Object.create( THREE.Material.prototype ); | |
| THREE.SpriteMaterial.prototype.constructor = THREE.SpriteMaterial; | |
| THREE.SpriteMaterial.prototype.copy = function ( source ) { | |
| THREE.Material.prototype.copy.call( this, source ); | |
| this.color.copy( source.color ); | |
| this.map = source.map; | |
| this.rotation = source.rotation; | |
| this.fog = source.fog; | |
| return this; | |
| }; | |
| // File:src/textures/Texture.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author szimek / https://github.com/szimek/ | |
| */ | |
| THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) { | |
| Object.defineProperty( this, 'id', { value: THREE.TextureIdCount ++ } ); | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.name = ''; | |
| this.sourceFile = ''; | |
| this.image = image !== undefined ? image : THREE.Texture.DEFAULT_IMAGE; | |
| this.mipmaps = []; | |
| this.mapping = mapping !== undefined ? mapping : THREE.Texture.DEFAULT_MAPPING; | |
| this.wrapS = wrapS !== undefined ? wrapS : THREE.ClampToEdgeWrapping; | |
| this.wrapT = wrapT !== undefined ? wrapT : THREE.ClampToEdgeWrapping; | |
| this.magFilter = magFilter !== undefined ? magFilter : THREE.LinearFilter; | |
| this.minFilter = minFilter !== undefined ? minFilter : THREE.LinearMipMapLinearFilter; | |
| this.anisotropy = anisotropy !== undefined ? anisotropy : 1; | |
| this.format = format !== undefined ? format : THREE.RGBAFormat; | |
| this.type = type !== undefined ? type : THREE.UnsignedByteType; | |
| this.offset = new THREE.Vector2( 0, 0 ); | |
| this.repeat = new THREE.Vector2( 1, 1 ); | |
| this.generateMipmaps = true; | |
| this.premultiplyAlpha = false; | |
| this.flipY = true; | |
| this.unpackAlignment = 4; // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml) | |
| this.version = 0; | |
| this.onUpdate = null; | |
| }; | |
| THREE.Texture.DEFAULT_IMAGE = undefined; | |
| THREE.Texture.DEFAULT_MAPPING = THREE.UVMapping; | |
| THREE.Texture.prototype = { | |
| constructor: THREE.Texture, | |
| set needsUpdate ( value ) { | |
| if ( value === true ) this.version ++; | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( source ) { | |
| this.image = source.image; | |
| this.mipmaps = source.mipmaps.slice( 0 ); | |
| this.mapping = source.mapping; | |
| this.wrapS = source.wrapS; | |
| this.wrapT = source.wrapT; | |
| this.magFilter = source.magFilter; | |
| this.minFilter = source.minFilter; | |
| this.anisotropy = source.anisotropy; | |
| this.format = source.format; | |
| this.type = source.type; | |
| this.offset.copy( source.offset ); | |
| this.repeat.copy( source.repeat ); | |
| this.generateMipmaps = source.generateMipmaps; | |
| this.premultiplyAlpha = source.premultiplyAlpha; | |
| this.flipY = source.flipY; | |
| this.unpackAlignment = source.unpackAlignment; | |
| return this; | |
| }, | |
| toJSON: function ( meta ) { | |
| if ( meta.textures[ this.uuid ] !== undefined ) { | |
| return meta.textures[ this.uuid ]; | |
| } | |
| function getDataURL( image ) { | |
| var canvas; | |
| if ( image.toDataURL !== undefined ) { | |
| canvas = image; | |
| } else { | |
| canvas = document.createElement( 'canvas' ); | |
| canvas.width = image.width; | |
| canvas.height = image.height; | |
| canvas.getContext( '2d' ).drawImage( image, 0, 0, image.width, image.height ); | |
| } | |
| if ( canvas.width > 2048 || canvas.height > 2048 ) { | |
| return canvas.toDataURL( 'image/jpeg', 0.6 ); | |
| } else { | |
| return canvas.toDataURL( 'image/png' ); | |
| } | |
| } | |
| var output = { | |
| metadata: { | |
| version: 4.4, | |
| type: 'Texture', | |
| generator: 'Texture.toJSON' | |
| }, | |
| uuid: this.uuid, | |
| name: this.name, | |
| mapping: this.mapping, | |
| repeat: [ this.repeat.x, this.repeat.y ], | |
| offset: [ this.offset.x, this.offset.y ], | |
| wrap: [ this.wrapS, this.wrapT ], | |
| minFilter: this.minFilter, | |
| magFilter: this.magFilter, | |
| anisotropy: this.anisotropy | |
| }; | |
| if ( this.image !== undefined ) { | |
| // TODO: Move to THREE.Image | |
| var image = this.image; | |
| if ( image.uuid === undefined ) { | |
| image.uuid = THREE.Math.generateUUID(); // UGH | |
| } | |
| if ( meta.images[ image.uuid ] === undefined ) { | |
| meta.images[ image.uuid ] = { | |
| uuid: image.uuid, | |
| url: getDataURL( image ) | |
| }; | |
| } | |
| output.image = image.uuid; | |
| } | |
| meta.textures[ this.uuid ] = output; | |
| return output; | |
| }, | |
| dispose: function () { | |
| this.dispatchEvent( { type: 'dispose' } ); | |
| }, | |
| transformUv: function ( uv ) { | |
| if ( this.mapping !== THREE.UVMapping ) return; | |
| uv.multiply( this.repeat ); | |
| uv.add( this.offset ); | |
| if ( uv.x < 0 || uv.x > 1 ) { | |
| switch ( this.wrapS ) { | |
| case THREE.RepeatWrapping: | |
| uv.x = uv.x - Math.floor( uv.x ); | |
| break; | |
| case THREE.ClampToEdgeWrapping: | |
| uv.x = uv.x < 0 ? 0 : 1; | |
| break; | |
| case THREE.MirroredRepeatWrapping: | |
| if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) { | |
| uv.x = Math.ceil( uv.x ) - uv.x; | |
| } else { | |
| uv.x = uv.x - Math.floor( uv.x ); | |
| } | |
| break; | |
| } | |
| } | |
| if ( uv.y < 0 || uv.y > 1 ) { | |
| switch ( this.wrapT ) { | |
| case THREE.RepeatWrapping: | |
| uv.y = uv.y - Math.floor( uv.y ); | |
| break; | |
| case THREE.ClampToEdgeWrapping: | |
| uv.y = uv.y < 0 ? 0 : 1; | |
| break; | |
| case THREE.MirroredRepeatWrapping: | |
| if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) { | |
| uv.y = Math.ceil( uv.y ) - uv.y; | |
| } else { | |
| uv.y = uv.y - Math.floor( uv.y ); | |
| } | |
| break; | |
| } | |
| } | |
| if ( this.flipY ) { | |
| uv.y = 1 - uv.y; | |
| } | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.Texture.prototype ); | |
| THREE.TextureIdCount = 0; | |
| // File:src/textures/CanvasTexture.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.CanvasTexture = function ( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) { | |
| THREE.Texture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); | |
| this.needsUpdate = true; | |
| }; | |
| THREE.CanvasTexture.prototype = Object.create( THREE.Texture.prototype ); | |
| THREE.CanvasTexture.prototype.constructor = THREE.CanvasTexture; | |
| // File:src/textures/CubeTexture.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.CubeTexture = function ( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) { | |
| mapping = mapping !== undefined ? mapping : THREE.CubeReflectionMapping; | |
| THREE.Texture.call( this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); | |
| this.images = images; | |
| this.flipY = false; | |
| }; | |
| THREE.CubeTexture.prototype = Object.create( THREE.Texture.prototype ); | |
| THREE.CubeTexture.prototype.constructor = THREE.CubeTexture; | |
| THREE.CubeTexture.prototype.copy = function ( source ) { | |
| THREE.Texture.prototype.copy.call( this, source ); | |
| this.images = source.images; | |
| return this; | |
| }; | |
| // File:src/textures/CompressedTexture.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.CompressedTexture = function ( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy ) { | |
| THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); | |
| this.image = { width: width, height: height }; | |
| this.mipmaps = mipmaps; | |
| // no flipping for cube textures | |
| // (also flipping doesn't work for compressed textures ) | |
| this.flipY = false; | |
| // can't generate mipmaps for compressed textures | |
| // mips must be embedded in DDS files | |
| this.generateMipmaps = false; | |
| }; | |
| THREE.CompressedTexture.prototype = Object.create( THREE.Texture.prototype ); | |
| THREE.CompressedTexture.prototype.constructor = THREE.CompressedTexture; | |
| // File:src/textures/DataTexture.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.DataTexture = function ( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy ) { | |
| THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); | |
| this.image = { data: data, width: width, height: height }; | |
| this.magFilter = magFilter !== undefined ? magFilter : THREE.NearestFilter; | |
| this.minFilter = minFilter !== undefined ? minFilter : THREE.NearestFilter; | |
| this.flipY = false; | |
| this.generateMipmaps = false; | |
| }; | |
| THREE.DataTexture.prototype = Object.create( THREE.Texture.prototype ); | |
| THREE.DataTexture.prototype.constructor = THREE.DataTexture; | |
| // File:src/textures/VideoTexture.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.VideoTexture = function ( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) { | |
| THREE.Texture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ); | |
| this.generateMipmaps = false; | |
| var scope = this; | |
| function update() { | |
| requestAnimationFrame( update ); | |
| if ( video.readyState === video.HAVE_ENOUGH_DATA ) { | |
| scope.needsUpdate = true; | |
| } | |
| } | |
| update(); | |
| }; | |
| THREE.VideoTexture.prototype = Object.create( THREE.Texture.prototype ); | |
| THREE.VideoTexture.prototype.constructor = THREE.VideoTexture; | |
| // File:src/objects/Group.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Group = function () { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Group'; | |
| }; | |
| THREE.Group.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Group.prototype.constructor = THREE.Group; | |
| // File:src/objects/Points.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Points = function ( geometry, material ) { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Points'; | |
| this.geometry = geometry !== undefined ? geometry : new THREE.Geometry(); | |
| this.material = material !== undefined ? material : new THREE.PointsMaterial( { color: Math.random() * 0xffffff } ); | |
| }; | |
| THREE.Points.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Points.prototype.constructor = THREE.Points; | |
| THREE.Points.prototype.raycast = ( function () { | |
| var inverseMatrix = new THREE.Matrix4(); | |
| var ray = new THREE.Ray(); | |
| var sphere = new THREE.Sphere(); | |
| return function raycast( raycaster, intersects ) { | |
| var object = this; | |
| var geometry = this.geometry; | |
| var matrixWorld = this.matrixWorld; | |
| var threshold = raycaster.params.Points.threshold; | |
| // Checking boundingSphere distance to ray | |
| if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere(); | |
| sphere.copy( geometry.boundingSphere ); | |
| sphere.applyMatrix4( matrixWorld ); | |
| if ( raycaster.ray.intersectsSphere( sphere ) === false ) return; | |
| // | |
| inverseMatrix.getInverse( matrixWorld ); | |
| ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix ); | |
| var localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 ); | |
| var localThresholdSq = localThreshold * localThreshold; | |
| var position = new THREE.Vector3(); | |
| function testPoint( point, index ) { | |
| var rayPointDistanceSq = ray.distanceSqToPoint( point ); | |
| if ( rayPointDistanceSq < localThresholdSq ) { | |
| var intersectPoint = ray.closestPointToPoint( point ); | |
| intersectPoint.applyMatrix4( matrixWorld ); | |
| var distance = raycaster.ray.origin.distanceTo( intersectPoint ); | |
| if ( distance < raycaster.near || distance > raycaster.far ) return; | |
| intersects.push( { | |
| distance: distance, | |
| distanceToRay: Math.sqrt( rayPointDistanceSq ), | |
| point: intersectPoint.clone(), | |
| index: index, | |
| face: null, | |
| object: object | |
| } ); | |
| } | |
| } | |
| if ( geometry instanceof THREE.BufferGeometry ) { | |
| var index = geometry.index; | |
| var attributes = geometry.attributes; | |
| var positions = attributes.position.array; | |
| if ( index !== null ) { | |
| var indices = index.array; | |
| for ( var i = 0, il = indices.length; i < il; i ++ ) { | |
| var a = indices[ i ]; | |
| position.fromArray( positions, a * 3 ); | |
| testPoint( position, a ); | |
| } | |
| } else { | |
| for ( var i = 0, l = positions.length / 3; i < l; i ++ ) { | |
| position.fromArray( positions, i * 3 ); | |
| testPoint( position, i ); | |
| } | |
| } | |
| } else { | |
| var vertices = geometry.vertices; | |
| for ( var i = 0, l = vertices.length; i < l; i ++ ) { | |
| testPoint( vertices[ i ], i ); | |
| } | |
| } | |
| }; | |
| }() ); | |
| THREE.Points.prototype.clone = function () { | |
| return new this.constructor( this.geometry, this.material ).copy( this ); | |
| }; | |
| // File:src/objects/Line.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Line = function ( geometry, material, mode ) { | |
| if ( mode === 1 ) { | |
| console.warn( 'THREE.Line: parameter THREE.LinePieces no longer supported. Created THREE.LineSegments instead.' ); | |
| return new THREE.LineSegments( geometry, material ); | |
| } | |
| THREE.Object3D.call( this ); | |
| this.type = 'Line'; | |
| this.geometry = geometry !== undefined ? geometry : new THREE.Geometry(); | |
| this.material = material !== undefined ? material : new THREE.LineBasicMaterial( { color: Math.random() * 0xffffff } ); | |
| }; | |
| THREE.Line.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Line.prototype.constructor = THREE.Line; | |
| THREE.Line.prototype.raycast = ( function () { | |
| var inverseMatrix = new THREE.Matrix4(); | |
| var ray = new THREE.Ray(); | |
| var sphere = new THREE.Sphere(); | |
| return function raycast( raycaster, intersects ) { | |
| var precision = raycaster.linePrecision; | |
| var precisionSq = precision * precision; | |
| var geometry = this.geometry; | |
| var matrixWorld = this.matrixWorld; | |
| // Checking boundingSphere distance to ray | |
| if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere(); | |
| sphere.copy( geometry.boundingSphere ); | |
| sphere.applyMatrix4( matrixWorld ); | |
| if ( raycaster.ray.intersectsSphere( sphere ) === false ) return; | |
| // | |
| inverseMatrix.getInverse( matrixWorld ); | |
| ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix ); | |
| var vStart = new THREE.Vector3(); | |
| var vEnd = new THREE.Vector3(); | |
| var interSegment = new THREE.Vector3(); | |
| var interRay = new THREE.Vector3(); | |
| var step = this instanceof THREE.LineSegments ? 2 : 1; | |
| if ( geometry instanceof THREE.BufferGeometry ) { | |
| var index = geometry.index; | |
| var attributes = geometry.attributes; | |
| var positions = attributes.position.array; | |
| if ( index !== null ) { | |
| var indices = index.array; | |
| for ( var i = 0, l = indices.length - 1; i < l; i += step ) { | |
| var a = indices[ i ]; | |
| var b = indices[ i + 1 ]; | |
| vStart.fromArray( positions, a * 3 ); | |
| vEnd.fromArray( positions, b * 3 ); | |
| var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment ); | |
| if ( distSq > precisionSq ) continue; | |
| interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation | |
| var distance = raycaster.ray.origin.distanceTo( interRay ); | |
| if ( distance < raycaster.near || distance > raycaster.far ) continue; | |
| intersects.push( { | |
| distance: distance, | |
| // What do we want? intersection point on the ray or on the segment?? | |
| // point: raycaster.ray.at( distance ), | |
| point: interSegment.clone().applyMatrix4( this.matrixWorld ), | |
| index: i, | |
| face: null, | |
| faceIndex: null, | |
| object: this | |
| } ); | |
| } | |
| } else { | |
| for ( var i = 0, l = positions.length / 3 - 1; i < l; i += step ) { | |
| vStart.fromArray( positions, 3 * i ); | |
| vEnd.fromArray( positions, 3 * i + 3 ); | |
| var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment ); | |
| if ( distSq > precisionSq ) continue; | |
| interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation | |
| var distance = raycaster.ray.origin.distanceTo( interRay ); | |
| if ( distance < raycaster.near || distance > raycaster.far ) continue; | |
| intersects.push( { | |
| distance: distance, | |
| // What do we want? intersection point on the ray or on the segment?? | |
| // point: raycaster.ray.at( distance ), | |
| point: interSegment.clone().applyMatrix4( this.matrixWorld ), | |
| index: i, | |
| face: null, | |
| faceIndex: null, | |
| object: this | |
| } ); | |
| } | |
| } | |
| } else if ( geometry instanceof THREE.Geometry ) { | |
| var vertices = geometry.vertices; | |
| var nbVertices = vertices.length; | |
| for ( var i = 0; i < nbVertices - 1; i += step ) { | |
| var distSq = ray.distanceSqToSegment( vertices[ i ], vertices[ i + 1 ], interRay, interSegment ); | |
| if ( distSq > precisionSq ) continue; | |
| interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation | |
| var distance = raycaster.ray.origin.distanceTo( interRay ); | |
| if ( distance < raycaster.near || distance > raycaster.far ) continue; | |
| intersects.push( { | |
| distance: distance, | |
| // What do we want? intersection point on the ray or on the segment?? | |
| // point: raycaster.ray.at( distance ), | |
| point: interSegment.clone().applyMatrix4( this.matrixWorld ), | |
| index: i, | |
| face: null, | |
| faceIndex: null, | |
| object: this | |
| } ); | |
| } | |
| } | |
| }; | |
| }() ); | |
| THREE.Line.prototype.clone = function () { | |
| return new this.constructor( this.geometry, this.material ).copy( this ); | |
| }; | |
| // DEPRECATED | |
| THREE.LineStrip = 0; | |
| THREE.LinePieces = 1; | |
| // File:src/objects/LineSegments.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.LineSegments = function ( geometry, material ) { | |
| THREE.Line.call( this, geometry, material ); | |
| this.type = 'LineSegments'; | |
| }; | |
| THREE.LineSegments.prototype = Object.create( THREE.Line.prototype ); | |
| THREE.LineSegments.prototype.constructor = THREE.LineSegments; | |
| // File:src/objects/Mesh.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author jonobr1 / http://jonobr1.com/ | |
| */ | |
| THREE.Mesh = function ( geometry, material ) { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Mesh'; | |
| this.geometry = geometry !== undefined ? geometry : new THREE.Geometry(); | |
| this.material = material !== undefined ? material : new THREE.MeshBasicMaterial( { color: Math.random() * 0xffffff } ); | |
| this.drawMode = THREE.TrianglesDrawMode; | |
| this.updateMorphTargets(); | |
| }; | |
| THREE.Mesh.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Mesh.prototype.constructor = THREE.Mesh; | |
| THREE.Mesh.prototype.setDrawMode = function ( value ) { | |
| this.drawMode = value; | |
| }; | |
| THREE.Mesh.prototype.updateMorphTargets = function () { | |
| if ( this.geometry.morphTargets !== undefined && this.geometry.morphTargets.length > 0 ) { | |
| this.morphTargetBase = - 1; | |
| this.morphTargetInfluences = []; | |
| this.morphTargetDictionary = {}; | |
| for ( var m = 0, ml = this.geometry.morphTargets.length; m < ml; m ++ ) { | |
| this.morphTargetInfluences.push( 0 ); | |
| this.morphTargetDictionary[ this.geometry.morphTargets[ m ].name ] = m; | |
| } | |
| } | |
| }; | |
| THREE.Mesh.prototype.getMorphTargetIndexByName = function ( name ) { | |
| if ( this.morphTargetDictionary[ name ] !== undefined ) { | |
| return this.morphTargetDictionary[ name ]; | |
| } | |
| console.warn( 'THREE.Mesh.getMorphTargetIndexByName: morph target ' + name + ' does not exist. Returning 0.' ); | |
| return 0; | |
| }; | |
| THREE.Mesh.prototype.raycast = ( function () { | |
| var inverseMatrix = new THREE.Matrix4(); | |
| var ray = new THREE.Ray(); | |
| var sphere = new THREE.Sphere(); | |
| var vA = new THREE.Vector3(); | |
| var vB = new THREE.Vector3(); | |
| var vC = new THREE.Vector3(); | |
| var tempA = new THREE.Vector3(); | |
| var tempB = new THREE.Vector3(); | |
| var tempC = new THREE.Vector3(); | |
| var uvA = new THREE.Vector2(); | |
| var uvB = new THREE.Vector2(); | |
| var uvC = new THREE.Vector2(); | |
| var barycoord = new THREE.Vector3(); | |
| var intersectionPoint = new THREE.Vector3(); | |
| var intersectionPointWorld = new THREE.Vector3(); | |
| function uvIntersection( point, p1, p2, p3, uv1, uv2, uv3 ) { | |
| THREE.Triangle.barycoordFromPoint( point, p1, p2, p3, barycoord ); | |
| uv1.multiplyScalar( barycoord.x ); | |
| uv2.multiplyScalar( barycoord.y ); | |
| uv3.multiplyScalar( barycoord.z ); | |
| uv1.add( uv2 ).add( uv3 ); | |
| return uv1.clone(); | |
| } | |
| function checkIntersection( object, raycaster, ray, pA, pB, pC, point ) { | |
| var intersect; | |
| var material = object.material; | |
| if ( material.side === THREE.BackSide ) { | |
| intersect = ray.intersectTriangle( pC, pB, pA, true, point ); | |
| } else { | |
| intersect = ray.intersectTriangle( pA, pB, pC, material.side !== THREE.DoubleSide, point ); | |
| } | |
| if ( intersect === null ) return null; | |
| intersectionPointWorld.copy( point ); | |
| intersectionPointWorld.applyMatrix4( object.matrixWorld ); | |
| var distance = raycaster.ray.origin.distanceTo( intersectionPointWorld ); | |
| if ( distance < raycaster.near || distance > raycaster.far ) return null; | |
| return { | |
| distance: distance, | |
| point: intersectionPointWorld.clone(), | |
| object: object | |
| }; | |
| } | |
| function checkBufferGeometryIntersection( object, raycaster, ray, positions, uvs, a, b, c ) { | |
| vA.fromArray( positions, a * 3 ); | |
| vB.fromArray( positions, b * 3 ); | |
| vC.fromArray( positions, c * 3 ); | |
| var intersection = checkIntersection( object, raycaster, ray, vA, vB, vC, intersectionPoint ); | |
| if ( intersection ) { | |
| if ( uvs ) { | |
| uvA.fromArray( uvs, a * 2 ); | |
| uvB.fromArray( uvs, b * 2 ); | |
| uvC.fromArray( uvs, c * 2 ); | |
| intersection.uv = uvIntersection( intersectionPoint, vA, vB, vC, uvA, uvB, uvC ); | |
| } | |
| intersection.face = new THREE.Face3( a, b, c, THREE.Triangle.normal( vA, vB, vC ) ); | |
| intersection.faceIndex = a; | |
| } | |
| return intersection; | |
| } | |
| return function raycast( raycaster, intersects ) { | |
| var geometry = this.geometry; | |
| var material = this.material; | |
| var matrixWorld = this.matrixWorld; | |
| if ( material === undefined ) return; | |
| // Checking boundingSphere distance to ray | |
| if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere(); | |
| sphere.copy( geometry.boundingSphere ); | |
| sphere.applyMatrix4( matrixWorld ); | |
| if ( raycaster.ray.intersectsSphere( sphere ) === false ) return; | |
| // | |
| inverseMatrix.getInverse( matrixWorld ); | |
| ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix ); | |
| // Check boundingBox before continuing | |
| if ( geometry.boundingBox !== null ) { | |
| if ( ray.intersectsBox( geometry.boundingBox ) === false ) return; | |
| } | |
| var uvs, intersection; | |
| if ( geometry instanceof THREE.BufferGeometry ) { | |
| var a, b, c; | |
| var index = geometry.index; | |
| var attributes = geometry.attributes; | |
| var positions = attributes.position.array; | |
| if ( attributes.uv !== undefined ) { | |
| uvs = attributes.uv.array; | |
| } | |
| if ( index !== null ) { | |
| var indices = index.array; | |
| for ( var i = 0, l = indices.length; i < l; i += 3 ) { | |
| a = indices[ i ]; | |
| b = indices[ i + 1 ]; | |
| c = indices[ i + 2 ]; | |
| intersection = checkBufferGeometryIntersection( this, raycaster, ray, positions, uvs, a, b, c ); | |
| if ( intersection ) { | |
| intersection.faceIndex = Math.floor( i / 3 ); // triangle number in indices buffer semantics | |
| intersects.push( intersection ); | |
| } | |
| } | |
| } else { | |
| for ( var i = 0, l = positions.length; i < l; i += 9 ) { | |
| a = i / 3; | |
| b = a + 1; | |
| c = a + 2; | |
| intersection = checkBufferGeometryIntersection( this, raycaster, ray, positions, uvs, a, b, c ); | |
| if ( intersection ) { | |
| intersection.index = a; // triangle number in positions buffer semantics | |
| intersects.push( intersection ); | |
| } | |
| } | |
| } | |
| } else if ( geometry instanceof THREE.Geometry ) { | |
| var fvA, fvB, fvC; | |
| var isFaceMaterial = material instanceof THREE.MultiMaterial; | |
| var materials = isFaceMaterial === true ? material.materials : null; | |
| var vertices = geometry.vertices; | |
| var faces = geometry.faces; | |
| var faceVertexUvs = geometry.faceVertexUvs[ 0 ]; | |
| if ( faceVertexUvs.length > 0 ) uvs = faceVertexUvs; | |
| for ( var f = 0, fl = faces.length; f < fl; f ++ ) { | |
| var face = faces[ f ]; | |
| var faceMaterial = isFaceMaterial === true ? materials[ face.materialIndex ] : material; | |
| if ( faceMaterial === undefined ) continue; | |
| fvA = vertices[ face.a ]; | |
| fvB = vertices[ face.b ]; | |
| fvC = vertices[ face.c ]; | |
| if ( faceMaterial.morphTargets === true ) { | |
| var morphTargets = geometry.morphTargets; | |
| var morphInfluences = this.morphTargetInfluences; | |
| vA.set( 0, 0, 0 ); | |
| vB.set( 0, 0, 0 ); | |
| vC.set( 0, 0, 0 ); | |
| for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) { | |
| var influence = morphInfluences[ t ]; | |
| if ( influence === 0 ) continue; | |
| var targets = morphTargets[ t ].vertices; | |
| vA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence ); | |
| vB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence ); | |
| vC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence ); | |
| } | |
| vA.add( fvA ); | |
| vB.add( fvB ); | |
| vC.add( fvC ); | |
| fvA = vA; | |
| fvB = vB; | |
| fvC = vC; | |
| } | |
| intersection = checkIntersection( this, raycaster, ray, fvA, fvB, fvC, intersectionPoint ); | |
| if ( intersection ) { | |
| if ( uvs ) { | |
| var uvs_f = uvs[ f ]; | |
| uvA.copy( uvs_f[ 0 ] ); | |
| uvB.copy( uvs_f[ 1 ] ); | |
| uvC.copy( uvs_f[ 2 ] ); | |
| intersection.uv = uvIntersection( intersectionPoint, fvA, fvB, fvC, uvA, uvB, uvC ); | |
| } | |
| intersection.face = face; | |
| intersection.faceIndex = f; | |
| intersects.push( intersection ); | |
| } | |
| } | |
| } | |
| }; | |
| }() ); | |
| THREE.Mesh.prototype.clone = function () { | |
| return new this.constructor( this.geometry, this.material ).copy( this ); | |
| }; | |
| // File:src/objects/Bone.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author ikerr / http://verold.com | |
| */ | |
| THREE.Bone = function ( skin ) { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Bone'; | |
| this.skin = skin; | |
| }; | |
| THREE.Bone.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Bone.prototype.constructor = THREE.Bone; | |
| THREE.Bone.prototype.copy = function ( source ) { | |
| THREE.Object3D.prototype.copy.call( this, source ); | |
| this.skin = source.skin; | |
| return this; | |
| }; | |
| // File:src/objects/Skeleton.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author michael guerrero / http://realitymeltdown.com | |
| * @author ikerr / http://verold.com | |
| */ | |
| THREE.Skeleton = function ( bones, boneInverses, useVertexTexture ) { | |
| this.useVertexTexture = useVertexTexture !== undefined ? useVertexTexture : true; | |
| this.identityMatrix = new THREE.Matrix4(); | |
| // copy the bone array | |
| bones = bones || []; | |
| this.bones = bones.slice( 0 ); | |
| // create a bone texture or an array of floats | |
| if ( this.useVertexTexture ) { | |
| // layout (1 matrix = 4 pixels) | |
| // RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4) | |
| // with 8x8 pixel texture max 16 bones * 4 pixels = (8 * 8) | |
| // 16x16 pixel texture max 64 bones * 4 pixels = (16 * 16) | |
| // 32x32 pixel texture max 256 bones * 4 pixels = (32 * 32) | |
| // 64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64) | |
| var size = Math.sqrt( this.bones.length * 4 ); // 4 pixels needed for 1 matrix | |
| size = THREE.Math.nextPowerOfTwo( Math.ceil( size ) ); | |
| size = Math.max( size, 4 ); | |
| this.boneTextureWidth = size; | |
| this.boneTextureHeight = size; | |
| this.boneMatrices = new Float32Array( this.boneTextureWidth * this.boneTextureHeight * 4 ); // 4 floats per RGBA pixel | |
| this.boneTexture = new THREE.DataTexture( this.boneMatrices, this.boneTextureWidth, this.boneTextureHeight, THREE.RGBAFormat, THREE.FloatType ); | |
| } else { | |
| this.boneMatrices = new Float32Array( 16 * this.bones.length ); | |
| } | |
| // use the supplied bone inverses or calculate the inverses | |
| if ( boneInverses === undefined ) { | |
| this.calculateInverses(); | |
| } else { | |
| if ( this.bones.length === boneInverses.length ) { | |
| this.boneInverses = boneInverses.slice( 0 ); | |
| } else { | |
| console.warn( 'THREE.Skeleton bonInverses is the wrong length.' ); | |
| this.boneInverses = []; | |
| for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) { | |
| this.boneInverses.push( new THREE.Matrix4() ); | |
| } | |
| } | |
| } | |
| }; | |
| THREE.Skeleton.prototype.calculateInverses = function () { | |
| this.boneInverses = []; | |
| for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) { | |
| var inverse = new THREE.Matrix4(); | |
| if ( this.bones[ b ] ) { | |
| inverse.getInverse( this.bones[ b ].matrixWorld ); | |
| } | |
| this.boneInverses.push( inverse ); | |
| } | |
| }; | |
| THREE.Skeleton.prototype.pose = function () { | |
| var bone; | |
| // recover the bind-time world matrices | |
| for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) { | |
| bone = this.bones[ b ]; | |
| if ( bone ) { | |
| bone.matrixWorld.getInverse( this.boneInverses[ b ] ); | |
| } | |
| } | |
| // compute the local matrices, positions, rotations and scales | |
| for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) { | |
| bone = this.bones[ b ]; | |
| if ( bone ) { | |
| if ( bone.parent ) { | |
| bone.matrix.getInverse( bone.parent.matrixWorld ); | |
| bone.matrix.multiply( bone.matrixWorld ); | |
| } else { | |
| bone.matrix.copy( bone.matrixWorld ); | |
| } | |
| bone.matrix.decompose( bone.position, bone.quaternion, bone.scale ); | |
| } | |
| } | |
| }; | |
| THREE.Skeleton.prototype.update = ( function () { | |
| var offsetMatrix = new THREE.Matrix4(); | |
| return function update() { | |
| // flatten bone matrices to array | |
| for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) { | |
| // compute the offset between the current and the original transform | |
| var matrix = this.bones[ b ] ? this.bones[ b ].matrixWorld : this.identityMatrix; | |
| offsetMatrix.multiplyMatrices( matrix, this.boneInverses[ b ] ); | |
| offsetMatrix.flattenToArrayOffset( this.boneMatrices, b * 16 ); | |
| } | |
| if ( this.useVertexTexture ) { | |
| this.boneTexture.needsUpdate = true; | |
| } | |
| }; | |
| } )(); | |
| THREE.Skeleton.prototype.clone = function () { | |
| return new THREE.Skeleton( this.bones, this.boneInverses, this.useVertexTexture ); | |
| }; | |
| // File:src/objects/SkinnedMesh.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author ikerr / http://verold.com | |
| */ | |
| THREE.SkinnedMesh = function ( geometry, material, useVertexTexture ) { | |
| THREE.Mesh.call( this, geometry, material ); | |
| this.type = 'SkinnedMesh'; | |
| this.bindMode = "attached"; | |
| this.bindMatrix = new THREE.Matrix4(); | |
| this.bindMatrixInverse = new THREE.Matrix4(); | |
| // init bones | |
| // TODO: remove bone creation as there is no reason (other than | |
| // convenience) for THREE.SkinnedMesh to do this. | |
| var bones = []; | |
| if ( this.geometry && this.geometry.bones !== undefined ) { | |
| var bone, gbone; | |
| for ( var b = 0, bl = this.geometry.bones.length; b < bl; ++ b ) { | |
| gbone = this.geometry.bones[ b ]; | |
| bone = new THREE.Bone( this ); | |
| bones.push( bone ); | |
| bone.name = gbone.name; | |
| bone.position.fromArray( gbone.pos ); | |
| bone.quaternion.fromArray( gbone.rotq ); | |
| if ( gbone.scl !== undefined ) bone.scale.fromArray( gbone.scl ); | |
| } | |
| for ( var b = 0, bl = this.geometry.bones.length; b < bl; ++ b ) { | |
| gbone = this.geometry.bones[ b ]; | |
| if ( gbone.parent !== - 1 && gbone.parent !== null ) { | |
| bones[ gbone.parent ].add( bones[ b ] ); | |
| } else { | |
| this.add( bones[ b ] ); | |
| } | |
| } | |
| } | |
| this.normalizeSkinWeights(); | |
| this.updateMatrixWorld( true ); | |
| this.bind( new THREE.Skeleton( bones, undefined, useVertexTexture ), this.matrixWorld ); | |
| }; | |
| THREE.SkinnedMesh.prototype = Object.create( THREE.Mesh.prototype ); | |
| THREE.SkinnedMesh.prototype.constructor = THREE.SkinnedMesh; | |
| THREE.SkinnedMesh.prototype.bind = function( skeleton, bindMatrix ) { | |
| this.skeleton = skeleton; | |
| if ( bindMatrix === undefined ) { | |
| this.updateMatrixWorld( true ); | |
| this.skeleton.calculateInverses(); | |
| bindMatrix = this.matrixWorld; | |
| } | |
| this.bindMatrix.copy( bindMatrix ); | |
| this.bindMatrixInverse.getInverse( bindMatrix ); | |
| }; | |
| THREE.SkinnedMesh.prototype.pose = function () { | |
| this.skeleton.pose(); | |
| }; | |
| THREE.SkinnedMesh.prototype.normalizeSkinWeights = function () { | |
| if ( this.geometry instanceof THREE.Geometry ) { | |
| for ( var i = 0; i < this.geometry.skinWeights.length; i ++ ) { | |
| var sw = this.geometry.skinWeights[ i ]; | |
| var scale = 1.0 / sw.lengthManhattan(); | |
| if ( scale !== Infinity ) { | |
| sw.multiplyScalar( scale ); | |
| } else { | |
| sw.set( 1, 0, 0, 0 ); // do something reasonable | |
| } | |
| } | |
| } else if ( this.geometry instanceof THREE.BufferGeometry ) { | |
| var vec = new THREE.Vector4(); | |
| var skinWeight = this.geometry.attributes.skinWeight; | |
| for ( var i = 0; i < skinWeight.count; i ++ ) { | |
| vec.x = skinWeight.getX( i ); | |
| vec.y = skinWeight.getY( i ); | |
| vec.z = skinWeight.getZ( i ); | |
| vec.w = skinWeight.getW( i ); | |
| var scale = 1.0 / vec.lengthManhattan(); | |
| if ( scale !== Infinity ) { | |
| vec.multiplyScalar( scale ); | |
| } else { | |
| vec.set( 1, 0, 0, 0 ); // do something reasonable | |
| } | |
| skinWeight.setXYZW( i, vec.x, vec.y, vec.z, vec.w ); | |
| } | |
| } | |
| }; | |
| THREE.SkinnedMesh.prototype.updateMatrixWorld = function( force ) { | |
| THREE.Mesh.prototype.updateMatrixWorld.call( this, true ); | |
| if ( this.bindMode === "attached" ) { | |
| this.bindMatrixInverse.getInverse( this.matrixWorld ); | |
| } else if ( this.bindMode === "detached" ) { | |
| this.bindMatrixInverse.getInverse( this.bindMatrix ); | |
| } else { | |
| console.warn( 'THREE.SkinnedMesh unrecognized bindMode: ' + this.bindMode ); | |
| } | |
| }; | |
| THREE.SkinnedMesh.prototype.clone = function() { | |
| return new this.constructor( this.geometry, this.material, this.useVertexTexture ).copy( this ); | |
| }; | |
| // File:src/objects/LOD.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.LOD = function () { | |
| THREE.Object3D.call( this ); | |
| this.type = 'LOD'; | |
| Object.defineProperties( this, { | |
| levels: { | |
| enumerable: true, | |
| value: [] | |
| }, | |
| objects: { | |
| get: function () { | |
| console.warn( 'THREE.LOD: .objects has been renamed to .levels.' ); | |
| return this.levels; | |
| } | |
| } | |
| } ); | |
| }; | |
| THREE.LOD.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.LOD.prototype.constructor = THREE.LOD; | |
| THREE.LOD.prototype.addLevel = function ( object, distance ) { | |
| if ( distance === undefined ) distance = 0; | |
| distance = Math.abs( distance ); | |
| var levels = this.levels; | |
| for ( var l = 0; l < levels.length; l ++ ) { | |
| if ( distance < levels[ l ].distance ) { | |
| break; | |
| } | |
| } | |
| levels.splice( l, 0, { distance: distance, object: object } ); | |
| this.add( object ); | |
| }; | |
| THREE.LOD.prototype.getObjectForDistance = function ( distance ) { | |
| var levels = this.levels; | |
| for ( var i = 1, l = levels.length; i < l; i ++ ) { | |
| if ( distance < levels[ i ].distance ) { | |
| break; | |
| } | |
| } | |
| return levels[ i - 1 ].object; | |
| }; | |
| THREE.LOD.prototype.raycast = ( function () { | |
| var matrixPosition = new THREE.Vector3(); | |
| return function raycast( raycaster, intersects ) { | |
| matrixPosition.setFromMatrixPosition( this.matrixWorld ); | |
| var distance = raycaster.ray.origin.distanceTo( matrixPosition ); | |
| this.getObjectForDistance( distance ).raycast( raycaster, intersects ); | |
| }; | |
| }() ); | |
| THREE.LOD.prototype.update = function () { | |
| var v1 = new THREE.Vector3(); | |
| var v2 = new THREE.Vector3(); | |
| return function update( camera ) { | |
| var levels = this.levels; | |
| if ( levels.length > 1 ) { | |
| v1.setFromMatrixPosition( camera.matrixWorld ); | |
| v2.setFromMatrixPosition( this.matrixWorld ); | |
| var distance = v1.distanceTo( v2 ); | |
| levels[ 0 ].object.visible = true; | |
| for ( var i = 1, l = levels.length; i < l; i ++ ) { | |
| if ( distance >= levels[ i ].distance ) { | |
| levels[ i - 1 ].object.visible = false; | |
| levels[ i ].object.visible = true; | |
| } else { | |
| break; | |
| } | |
| } | |
| for ( ; i < l; i ++ ) { | |
| levels[ i ].object.visible = false; | |
| } | |
| } | |
| }; | |
| }(); | |
| THREE.LOD.prototype.copy = function ( source ) { | |
| THREE.Object3D.prototype.copy.call( this, source, false ); | |
| var levels = source.levels; | |
| for ( var i = 0, l = levels.length; i < l; i ++ ) { | |
| var level = levels[ i ]; | |
| this.addLevel( level.object.clone(), level.distance ); | |
| } | |
| return this; | |
| }; | |
| THREE.LOD.prototype.toJSON = function ( meta ) { | |
| var data = THREE.Object3D.prototype.toJSON.call( this, meta ); | |
| data.object.levels = []; | |
| var levels = this.levels; | |
| for ( var i = 0, l = levels.length; i < l; i ++ ) { | |
| var level = levels[ i ]; | |
| data.object.levels.push( { | |
| object: level.object.uuid, | |
| distance: level.distance | |
| } ); | |
| } | |
| return data; | |
| }; | |
| // File:src/objects/Sprite.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Sprite = ( function () { | |
| var indices = new Uint16Array( [ 0, 1, 2, 0, 2, 3 ] ); | |
| var vertices = new Float32Array( [ - 0.5, - 0.5, 0, 0.5, - 0.5, 0, 0.5, 0.5, 0, - 0.5, 0.5, 0 ] ); | |
| var uvs = new Float32Array( [ 0, 0, 1, 0, 1, 1, 0, 1 ] ); | |
| var geometry = new THREE.BufferGeometry(); | |
| geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) ); | |
| geometry.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) ); | |
| geometry.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) ); | |
| return function Sprite( material ) { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Sprite'; | |
| this.geometry = geometry; | |
| this.material = ( material !== undefined ) ? material : new THREE.SpriteMaterial(); | |
| }; | |
| } )(); | |
| THREE.Sprite.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Sprite.prototype.constructor = THREE.Sprite; | |
| THREE.Sprite.prototype.raycast = ( function () { | |
| var matrixPosition = new THREE.Vector3(); | |
| return function raycast( raycaster, intersects ) { | |
| matrixPosition.setFromMatrixPosition( this.matrixWorld ); | |
| var distanceSq = raycaster.ray.distanceSqToPoint( matrixPosition ); | |
| var guessSizeSq = this.scale.x * this.scale.y; | |
| if ( distanceSq > guessSizeSq ) { | |
| return; | |
| } | |
| intersects.push( { | |
| distance: Math.sqrt( distanceSq ), | |
| point: this.position, | |
| face: null, | |
| object: this | |
| } ); | |
| }; | |
| }() ); | |
| THREE.Sprite.prototype.clone = function () { | |
| return new this.constructor( this.material ).copy( this ); | |
| }; | |
| // Backwards compatibility | |
| THREE.Particle = THREE.Sprite; | |
| // File:src/objects/LensFlare.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.LensFlare = function ( texture, size, distance, blending, color ) { | |
| THREE.Object3D.call( this ); | |
| this.lensFlares = []; | |
| this.positionScreen = new THREE.Vector3(); | |
| this.customUpdateCallback = undefined; | |
| if ( texture !== undefined ) { | |
| this.add( texture, size, distance, blending, color ); | |
| } | |
| }; | |
| THREE.LensFlare.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.LensFlare.prototype.constructor = THREE.LensFlare; | |
| /* | |
| * Add: adds another flare | |
| */ | |
| THREE.LensFlare.prototype.add = function ( texture, size, distance, blending, color, opacity ) { | |
| if ( size === undefined ) size = - 1; | |
| if ( distance === undefined ) distance = 0; | |
| if ( opacity === undefined ) opacity = 1; | |
| if ( color === undefined ) color = new THREE.Color( 0xffffff ); | |
| if ( blending === undefined ) blending = THREE.NormalBlending; | |
| distance = Math.min( distance, Math.max( 0, distance ) ); | |
| this.lensFlares.push( { | |
| texture: texture, // THREE.Texture | |
| size: size, // size in pixels (-1 = use texture.width) | |
| distance: distance, // distance (0-1) from light source (0=at light source) | |
| x: 0, y: 0, z: 0, // screen position (-1 => 1) z = 0 is in front z = 1 is back | |
| scale: 1, // scale | |
| rotation: 0, // rotation | |
| opacity: opacity, // opacity | |
| color: color, // color | |
| blending: blending // blending | |
| } ); | |
| }; | |
| /* | |
| * Update lens flares update positions on all flares based on the screen position | |
| * Set myLensFlare.customUpdateCallback to alter the flares in your project specific way. | |
| */ | |
| THREE.LensFlare.prototype.updateLensFlares = function () { | |
| var f, fl = this.lensFlares.length; | |
| var flare; | |
| var vecX = - this.positionScreen.x * 2; | |
| var vecY = - this.positionScreen.y * 2; | |
| for ( f = 0; f < fl; f ++ ) { | |
| flare = this.lensFlares[ f ]; | |
| flare.x = this.positionScreen.x + vecX * flare.distance; | |
| flare.y = this.positionScreen.y + vecY * flare.distance; | |
| flare.wantedRotation = flare.x * Math.PI * 0.25; | |
| flare.rotation += ( flare.wantedRotation - flare.rotation ) * 0.25; | |
| } | |
| }; | |
| THREE.LensFlare.prototype.copy = function ( source ) { | |
| THREE.Object3D.prototype.copy.call( this, source ); | |
| this.positionScreen.copy( source.positionScreen ); | |
| this.customUpdateCallback = source.customUpdateCallback; | |
| for ( var i = 0, l = source.lensFlares.length; i < l; i ++ ) { | |
| this.lensFlares.push( source.lensFlares[ i ] ); | |
| } | |
| return this; | |
| }; | |
| // File:src/scenes/Scene.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.Scene = function () { | |
| THREE.Object3D.call( this ); | |
| this.type = 'Scene'; | |
| this.fog = null; | |
| this.overrideMaterial = null; | |
| this.autoUpdate = true; // checked by the renderer | |
| }; | |
| THREE.Scene.prototype = Object.create( THREE.Object3D.prototype ); | |
| THREE.Scene.prototype.constructor = THREE.Scene; | |
| THREE.Scene.prototype.copy = function ( source ) { | |
| THREE.Object3D.prototype.copy.call( this, source ); | |
| if ( source.fog !== null ) this.fog = source.fog.clone(); | |
| if ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone(); | |
| this.autoUpdate = source.autoUpdate; | |
| this.matrixAutoUpdate = source.matrixAutoUpdate; | |
| return this; | |
| }; | |
| // File:src/scenes/Fog.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.Fog = function ( color, near, far ) { | |
| this.name = ''; | |
| this.color = new THREE.Color( color ); | |
| this.near = ( near !== undefined ) ? near : 1; | |
| this.far = ( far !== undefined ) ? far : 1000; | |
| }; | |
| THREE.Fog.prototype.clone = function () { | |
| return new THREE.Fog( this.color.getHex(), this.near, this.far ); | |
| }; | |
| // File:src/scenes/FogExp2.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.FogExp2 = function ( color, density ) { | |
| this.name = ''; | |
| this.color = new THREE.Color( color ); | |
| this.density = ( density !== undefined ) ? density : 0.00025; | |
| }; | |
| THREE.FogExp2.prototype.clone = function () { | |
| return new THREE.FogExp2( this.color.getHex(), this.density ); | |
| }; | |
| // File:src/renderers/shaders/ShaderChunk.js | |
| THREE.ShaderChunk = {}; | |
| // File:src/renderers/shaders/ShaderChunk/alphamap_fragment.glsl | |
| THREE.ShaderChunk[ 'alphamap_fragment' ] = "#ifdef USE_ALPHAMAP\n diffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/alphamap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'alphamap_pars_fragment' ] = "#ifdef USE_ALPHAMAP\n uniform sampler2D alphaMap;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/alphatest_fragment.glsl | |
| THREE.ShaderChunk[ 'alphatest_fragment' ] = "#ifdef ALPHATEST\n if ( diffuseColor.a < ALPHATEST ) discard;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/ambient_pars.glsl | |
| THREE.ShaderChunk[ 'ambient_pars' ] = "uniform vec3 ambientLightColor;\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n return PI * ambientLightColor;\n}\n"; | |
| // File:src/renderers/shaders/ShaderChunk/aomap_fragment.glsl | |
| THREE.ShaderChunk[ 'aomap_fragment' ] = "#ifdef USE_AOMAP\n reflectedLight.indirectDiffuse *= ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/aomap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'aomap_pars_fragment' ] = "#ifdef USE_AOMAP\n uniform sampler2D aoMap;\n uniform float aoMapIntensity;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/begin_vertex.glsl | |
| THREE.ShaderChunk[ 'begin_vertex' ] = "\nvec3 transformed = vec3( position );\n"; | |
| // File:src/renderers/shaders/ShaderChunk/beginnormal_vertex.glsl | |
| THREE.ShaderChunk[ 'beginnormal_vertex' ] = "\nvec3 objectNormal = vec3( normal );\n"; | |
| // File:src/renderers/shaders/ShaderChunk/bsdfs.glsl | |
| THREE.ShaderChunk[ 'bsdfs' ] = "float calcLightAttenuation( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n if ( decayExponent > 0.0 ) {\n return pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n }\n return 1.0;\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n return RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n float fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n return ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n float a2 = alpha * alpha;\n float gl = dotNL + pow( a2 + ( 1.0 - a2 ) * dotNL * dotNL, 0.5 );\n float gv = dotNV + pow( a2 + ( 1.0 - a2 ) * dotNV * dotNV, 0.5 );\n return 1.0 / ( gl * gv );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n float a2 = alpha * alpha;\n float denom = dotNH * dotNH * ( a2 - 1.0 ) + 1.0;\n return RECIPROCAL_PI * a2 / ( denom * denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n float alpha = roughness * roughness;\n vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n float dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );\n float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n float dotNH = saturate( dot( geometry.normal, halfDir ) );\n float dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n vec3 F = F_Schlick( specularColor, dotLH );\n float G = G_GGX_Smith( alpha, dotNL, dotNV );\n float D = D_GGX( alpha, dotNH );\n return F * ( G * D );\n}\nvec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n vec4 r = roughness * c0 + c1;\n float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;\n return specularColor * AB.x + AB.y;\n}\nfloat G_BlinnPhong_Implicit( ) {\n return 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n float dotNH = saturate( dot( geometry.normal, halfDir ) );\n float dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n vec3 F = F_Schlick( specularColor, dotLH );\n float G = G_BlinnPhong_Implicit( );\n float D = D_BlinnPhong( shininess, dotNH );\n return F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n return ( 2.0 / square( ggxRoughness + 0.0001 ) - 2.0 );\n}"; | |
| // File:src/renderers/shaders/ShaderChunk/bumpmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'bumpmap_pars_fragment' ] = "#ifdef USE_BUMPMAP\n uniform sampler2D bumpMap;\n uniform float bumpScale;\n vec2 dHdxy_fwd() {\n vec2 dSTdx = dFdx( vUv );\n vec2 dSTdy = dFdy( vUv );\n float Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n return vec2( dBx, dBy );\n }\n vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n vec3 vSigmaX = dFdx( surf_pos );\n vec3 vSigmaY = dFdy( surf_pos );\n vec3 vN = surf_norm;\n vec3 R1 = cross( vSigmaY, vN );\n vec3 R2 = cross( vN, vSigmaX );\n float fDet = dot( vSigmaX, R1 );\n vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n return normalize( abs( fDet ) * surf_norm - vGrad );\n }\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/color_fragment.glsl | |
| THREE.ShaderChunk[ 'color_fragment' ] = "#ifdef USE_COLOR\n diffuseColor.rgb *= vColor;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/color_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'color_pars_fragment' ] = "#ifdef USE_COLOR\n varying vec3 vColor;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/color_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'color_pars_vertex' ] = "#ifdef USE_COLOR\n varying vec3 vColor;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/color_vertex.glsl | |
| THREE.ShaderChunk[ 'color_vertex' ] = "#ifdef USE_COLOR\n vColor.xyz = color.xyz;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/common.glsl | |
| THREE.ShaderChunk[ 'common' ] = "#define PI 3.14159\n#define PI2 6.28318\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\n#define LOG2 1.442695\n#define EPSILON 1e-6\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#define whiteCompliment(a) ( 1.0 - saturate( a ) )\nfloat square( const in float x ) { return x*x; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nstruct IncidentLight {\n vec3 color;\n vec3 direction;\n};\nstruct ReflectedLight {\n vec3 directDiffuse;\n vec3 directSpecular;\n vec3 indirectDiffuse;\n vec3 indirectSpecular;\n};\nstruct GeometricContext {\n vec3 position;\n vec3 normal;\n vec3 viewDir;\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n float distance = dot( planeNormal, point - pointOnPlane );\n return - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n return sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nvec3 inputToLinear( in vec3 a ) {\n #ifdef GAMMA_INPUT\n return pow( a, vec3( float( GAMMA_FACTOR ) ) );\n #else\n return a;\n #endif\n}\nvec3 linearToOutput( in vec3 a ) {\n #ifdef GAMMA_OUTPUT\n return pow( a, vec3( 1.0 / float( GAMMA_FACTOR ) ) );\n #else\n return a;\n #endif\n}\n"; | |
| // File:src/renderers/shaders/ShaderChunk/defaultnormal_vertex.glsl | |
| THREE.ShaderChunk[ 'defaultnormal_vertex' ] = "#ifdef FLIP_SIDED\n objectNormal = -objectNormal;\n#endif\nvec3 transformedNormal = normalMatrix * objectNormal;\n"; | |
| // File:src/renderers/shaders/ShaderChunk/displacementmap_vertex.glsl | |
| THREE.ShaderChunk[ 'displacementmap_vertex' ] = "#ifdef USE_DISPLACEMENTMAP\n transformed += normal * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/displacementmap_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'displacementmap_pars_vertex' ] = "#ifdef USE_DISPLACEMENTMAP\n uniform sampler2D displacementMap;\n uniform float displacementScale;\n uniform float displacementBias;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl | |
| THREE.ShaderChunk[ 'emissivemap_fragment' ] = "#ifdef USE_EMISSIVEMAP\n vec4 emissiveColor = texture2D( emissiveMap, vUv );\n emissiveColor.rgb = inputToLinear( emissiveColor.rgb );\n totalEmissiveLight *= emissiveColor.rgb;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'emissivemap_pars_fragment' ] = "#ifdef USE_EMISSIVEMAP\n uniform sampler2D emissiveMap;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/envmap_fragment.glsl | |
| THREE.ShaderChunk[ 'envmap_fragment' ] = "#ifdef USE_ENVMAP\n #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );\n vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n #ifdef ENVMAP_MODE_REFLECTION\n vec3 reflectVec = reflect( cameraToVertex, worldNormal );\n #else\n vec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );\n #endif\n #else\n vec3 reflectVec = vReflect;\n #endif\n #ifdef DOUBLE_SIDED\n float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n #else\n float flipNormal = 1.0;\n #endif\n #ifdef ENVMAP_TYPE_CUBE\n vec4 envColor = textureCube( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n #elif defined( ENVMAP_TYPE_EQUIREC )\n vec2 sampleUV;\n sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );\n sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n vec4 envColor = texture2D( envMap, sampleUV );\n #elif defined( ENVMAP_TYPE_SPHERE )\n vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));\n vec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n #endif\n envColor.xyz = inputToLinear( envColor.xyz );\n #ifdef ENVMAP_BLENDING_MULTIPLY\n outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n #elif defined( ENVMAP_BLENDING_MIX )\n outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n #elif defined( ENVMAP_BLENDING_ADD )\n outgoingLight += envColor.xyz * specularStrength * reflectivity;\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'envmap_pars_fragment' ] = "#if defined( USE_ENVMAP ) || defined( STANDARD )\n uniform float reflectivity;\n uniform float envMapIntenstiy;\n#endif\n#ifdef USE_ENVMAP\n #ifdef ENVMAP_TYPE_CUBE\n uniform samplerCube envMap;\n #else\n uniform sampler2D envMap;\n #endif\n uniform float flipEnvMap;\n #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( STANDARD )\n uniform float refractionRatio;\n #else\n varying vec3 vReflect;\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/envmap_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'envmap_pars_vertex' ] = "#if defined( USE_ENVMAP ) && ! defined( USE_BUMPMAP ) && ! defined( USE_NORMALMAP ) && ! defined( PHONG ) && ! defined( STANDARD )\n varying vec3 vReflect;\n uniform float refractionRatio;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/envmap_vertex.glsl | |
| THREE.ShaderChunk[ 'envmap_vertex' ] = "#if defined( USE_ENVMAP ) && ! defined( USE_BUMPMAP ) && ! defined( USE_NORMALMAP ) && ! defined( PHONG ) && ! defined( STANDARD )\n vec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n #ifdef ENVMAP_MODE_REFLECTION\n vReflect = reflect( cameraToVertex, worldNormal );\n #else\n vReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/fog_fragment.glsl | |
| THREE.ShaderChunk[ 'fog_fragment' ] = "#ifdef USE_FOG\n #ifdef USE_LOGDEPTHBUF_EXT\n float depth = gl_FragDepthEXT / gl_FragCoord.w;\n #else\n float depth = gl_FragCoord.z / gl_FragCoord.w;\n #endif\n #ifdef FOG_EXP2\n float fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * depth * depth * LOG2 ) );\n #else\n float fogFactor = smoothstep( fogNear, fogFar, depth );\n #endif\n \n outgoingLight = mix( outgoingLight, fogColor, fogFactor );\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/fog_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'fog_pars_fragment' ] = "#ifdef USE_FOG\n uniform vec3 fogColor;\n #ifdef FOG_EXP2\n uniform float fogDensity;\n #else\n uniform float fogNear;\n uniform float fogFar;\n #endif\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/lightmap_fragment.glsl | |
| THREE.ShaderChunk[ 'lightmap_fragment' ] = "#ifdef USE_LIGHTMAP\n reflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lightmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'lightmap_pars_fragment' ] = "#ifdef USE_LIGHTMAP\n uniform sampler2D lightMap;\n uniform float lightMapIntensity;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_lambert_vertex.glsl | |
| THREE.ShaderChunk[ 'lights_lambert_vertex' ] = "vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n vLightBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS > 0\n for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n directLight = getPointDirectLight( pointLights[ i ], geometry );\n dotNL = dot( geometry.normal, directLight.direction );\n directLightColor_Diffuse = PI * directLight.color;\n vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n #ifdef DOUBLE_SIDED\n vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n #endif\n }\n#endif\n#if NUM_SPOT_LIGHTS > 0\n for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n directLight = getSpotDirectLight( spotLights[ i ], geometry );\n dotNL = dot( geometry.normal, directLight.direction );\n directLightColor_Diffuse = PI * directLight.color;\n vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n #ifdef DOUBLE_SIDED\n vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n #endif\n }\n#endif\n#if NUM_DIR_LIGHTS > 0\n for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n directLight = getDirectionalDirectLight( directionalLights[ i ], geometry );\n dotNL = dot( geometry.normal, directLight.direction );\n directLightColor_Diffuse = PI * directLight.color;\n vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n #ifdef DOUBLE_SIDED\n vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n #endif\n }\n#endif\n#if NUM_HEMI_LIGHTS > 0\n for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n vLightFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n #ifdef DOUBLE_SIDED\n vLightBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n #endif\n }\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_pars.glsl | |
| THREE.ShaderChunk[ 'lights_pars' ] = "#if NUM_DIR_LIGHTS > 0\n struct DirectionalLight {\n vec3 direction;\n vec3 color;\n int shadow;\n float shadowBias;\n float shadowRadius;\n vec2 shadowMapSize;\n };\n uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n IncidentLight getDirectionalDirectLight( const in DirectionalLight directionalLight, const in GeometricContext geometry ) {\n IncidentLight directLight;\n directLight.color = directionalLight.color;\n directLight.direction = directionalLight.direction;\n return directLight;\n }\n#endif\n#if NUM_POINT_LIGHTS > 0\n struct PointLight {\n vec3 position;\n vec3 color;\n float distance;\n float decay;\n int shadow;\n float shadowBias;\n float shadowRadius;\n vec2 shadowMapSize;\n };\n uniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n IncidentLight getPointDirectLight( const in PointLight pointLight, const in GeometricContext geometry ) {\n IncidentLight directLight;\n vec3 lVector = pointLight.position - geometry.position;\n directLight.direction = normalize( lVector );\n directLight.color = pointLight.color;\n directLight.color *= calcLightAttenuation( length( lVector ), pointLight.distance, pointLight.decay );\n return directLight;\n }\n#endif\n#if NUM_SPOT_LIGHTS > 0\n struct SpotLight {\n vec3 position;\n vec3 direction;\n vec3 color;\n float distance;\n float decay;\n float angleCos;\n float exponent;\n int shadow;\n float shadowBias;\n float shadowRadius;\n vec2 shadowMapSize;\n };\n uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n IncidentLight getSpotDirectLight( const in SpotLight spotLight, const in GeometricContext geometry ) {\n IncidentLight directLight;\n vec3 lVector = spotLight.position - geometry.position;\n directLight.direction = normalize( lVector );\n float spotEffect = dot( directLight.direction, spotLight.direction );\n if ( spotEffect > spotLight.angleCos ) {\n float spotEffect = dot( spotLight.direction, directLight.direction );\n spotEffect = saturate( pow( saturate( spotEffect ), spotLight.exponent ) );\n directLight.color = spotLight.color;\n directLight.color *= ( spotEffect * calcLightAttenuation( length( lVector ), spotLight.distance, spotLight.decay ) );\n } else {\n directLight.color = vec3( 0.0 );\n }\n return directLight;\n }\n#endif\n#if NUM_HEMI_LIGHTS > 0\n struct HemisphereLight {\n vec3 direction;\n vec3 skyColor;\n vec3 groundColor;\n };\n uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n float dotNL = dot( geometry.normal, hemiLight.direction );\n float hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n return PI * mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n }\n#endif\n#if defined( USE_ENVMAP ) && defined( STANDARD )\n vec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n #ifdef DOUBLE_SIDED\n float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n #else\n float flipNormal = 1.0;\n #endif\n vec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n #ifdef ENVMAP_TYPE_CUBE\n vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n #ifdef TEXTURE_LOD_EXT\n vec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n #else\n vec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n #endif\n #else\n vec3 envMapColor = vec3( 0.0 );\n #endif\n envMapColor.rgb = inputToLinear( envMapColor.rgb );\n return PI * envMapColor.rgb * envMapIntensity;\n }\n float getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {\n float maxMIPLevelScalar = float( maxMIPLevel );\n float desiredMIPLevel = maxMIPLevelScalar - 0.79248 - 0.5 * log2( square( blinnShininessExponent ) + 1.0 );\n return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n }\n vec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {\n #ifdef ENVMAP_MODE_REFLECTION\n vec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );\n #else\n vec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );\n #endif\n #ifdef DOUBLE_SIDED\n float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n #else\n float flipNormal = 1.0;\n #endif\n reflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n float specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );\n #ifdef ENVMAP_TYPE_CUBE\n vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n #ifdef TEXTURE_LOD_EXT\n vec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n #else\n vec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n #endif\n #elif defined( ENVMAP_TYPE_EQUIREC )\n vec2 sampleUV;\n sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );\n sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n #ifdef TEXTURE_LOD_EXT\n vec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\n #else\n vec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );\n #endif\n #elif defined( ENVMAP_TYPE_SPHERE )\n vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));\n #ifdef TEXTURE_LOD_EXT\n vec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n #else\n vec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n #endif\n #endif\n envMapColor.rgb = inputToLinear( envMapColor.rgb );\n return envMapColor.rgb * envMapIntensity;\n }\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_phong_fragment.glsl | |
| THREE.ShaderChunk[ 'lights_phong_fragment' ] = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_phong_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'lights_phong_pars_fragment' ] = "#ifdef USE_ENVMAP\n varying vec3 vWorldPosition;\n#endif\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n varying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n vec3 diffuseColor;\n vec3 specularColor;\n float specularShininess;\n float specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n float dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n vec3 irradiance = dotNL * PI * directLight.color;\n reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n reflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct RE_Direct_BlinnPhong\n#define RE_IndirectDiffuse RE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material ) (0)\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_phong_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'lights_phong_pars_vertex' ] = "#ifdef USE_ENVMAP\n varying vec3 vWorldPosition;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_phong_vertex.glsl | |
| THREE.ShaderChunk[ 'lights_phong_vertex' ] = "#ifdef USE_ENVMAP\n vWorldPosition = worldPosition.xyz;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_standard_fragment.glsl | |
| THREE.ShaderChunk[ 'lights_standard_fragment' ] = "StandardMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\nmaterial.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_standard_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'lights_standard_pars_fragment' ] = "struct StandardMaterial {\n vec3 diffuseColor;\n float specularRoughness;\n vec3 specularColor;\n};\nvoid RE_Direct_Standard( const in IncidentLight directLight, const in GeometricContext geometry, const in StandardMaterial material, inout ReflectedLight reflectedLight ) {\n float dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n vec3 irradiance = dotNL * PI * directLight.color;\n reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n reflectedLight.directSpecular += irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );\n}\nvoid RE_IndirectDiffuse_Standard( const in vec3 irradiance, const in GeometricContext geometry, const in StandardMaterial material, inout ReflectedLight reflectedLight ) {\n reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Standard( const in vec3 radiance, const in GeometricContext geometry, const in StandardMaterial material, inout ReflectedLight reflectedLight ) {\n reflectedLight.indirectSpecular += radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );\n}\n#define RE_Direct RE_Direct_Standard\n#define RE_IndirectDiffuse RE_IndirectDiffuse_Standard\n#define RE_IndirectSpecular RE_IndirectSpecular_Standard\n#define Material_BlinnShininessExponent( material ) GGXRoughnessToBlinnExponent( material.specularRoughness )\n"; | |
| // File:src/renderers/shaders/ShaderChunk/lights_template.glsl | |
| THREE.ShaderChunk[ 'lights_template' ] = "\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = normalize( vViewPosition );\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n PointLight pointLight;\n for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n pointLight = pointLights[ i ];\n directLight = getPointDirectLight( pointLight, geometry );\n #ifdef USE_SHADOWMAP\n directLight.color *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n #endif\n RE_Direct( directLight, geometry, material, reflectedLight );\n }\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n SpotLight spotLight;\n for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n spotLight = spotLights[ i ];\n directLight = getSpotDirectLight( spotLight, geometry );\n #ifdef USE_SHADOWMAP\n directLight.color *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n #endif\n RE_Direct( directLight, geometry, material, reflectedLight );\n }\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n DirectionalLight directionalLight;\n for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n directionalLight = directionalLights[ i ];\n directLight = getDirectionalDirectLight( directionalLight, geometry );\n #ifdef USE_SHADOWMAP\n directLight.color *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n #endif\n RE_Direct( directLight, geometry, material, reflectedLight );\n }\n#endif\n#if defined( RE_IndirectDiffuse )\n vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n #ifdef USE_LIGHTMAP\n irradiance += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n #endif\n #if ( NUM_HEMI_LIGHTS > 0 )\n for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n }\n #endif\n RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n vec3 radiance = getLightProbeIndirectRadiance( geometry, Material_BlinnShininessExponent( material ), 8 );\n RE_IndirectSpecular( radiance, geometry, material, reflectedLight );\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/linear_to_gamma_fragment.glsl | |
| THREE.ShaderChunk[ 'linear_to_gamma_fragment' ] = "\n outgoingLight = linearToOutput( outgoingLight );\n"; | |
| // File:src/renderers/shaders/ShaderChunk/logdepthbuf_fragment.glsl | |
| THREE.ShaderChunk[ 'logdepthbuf_fragment' ] = "#if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)\n gl_FragDepthEXT = log2(vFragDepth) * logDepthBufFC * 0.5;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/logdepthbuf_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'logdepthbuf_pars_fragment' ] = "#ifdef USE_LOGDEPTHBUF\n uniform float logDepthBufFC;\n #ifdef USE_LOGDEPTHBUF_EXT\n varying float vFragDepth;\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/logdepthbuf_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'logdepthbuf_pars_vertex' ] = "#ifdef USE_LOGDEPTHBUF\n #ifdef USE_LOGDEPTHBUF_EXT\n varying float vFragDepth;\n #endif\n uniform float logDepthBufFC;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/logdepthbuf_vertex.glsl | |
| THREE.ShaderChunk[ 'logdepthbuf_vertex' ] = "#ifdef USE_LOGDEPTHBUF\n gl_Position.z = log2(max( EPSILON, gl_Position.w + 1.0 )) * logDepthBufFC;\n #ifdef USE_LOGDEPTHBUF_EXT\n vFragDepth = 1.0 + gl_Position.w;\n #else\n gl_Position.z = (gl_Position.z - 1.0) * gl_Position.w;\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/map_fragment.glsl | |
| THREE.ShaderChunk[ 'map_fragment' ] = "#ifdef USE_MAP\n vec4 texelColor = texture2D( map, vUv );\n texelColor.xyz = inputToLinear( texelColor.xyz );\n diffuseColor *= texelColor;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'map_pars_fragment' ] = "#ifdef USE_MAP\n uniform sampler2D map;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/map_particle_fragment.glsl | |
| THREE.ShaderChunk[ 'map_particle_fragment' ] = "#ifdef USE_MAP\n diffuseColor *= texture2D( map, vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y ) * offsetRepeat.zw + offsetRepeat.xy );\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'map_particle_pars_fragment' ] = "#ifdef USE_MAP\n uniform vec4 offsetRepeat;\n uniform sampler2D map;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/metalnessmap_fragment.glsl | |
| THREE.ShaderChunk[ 'metalnessmap_fragment' ] = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n vec4 texelMetalness = texture2D( metalnessMap, vUv );\n metalnessFactor *= texelMetalness.r;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/metalnessmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'metalnessmap_pars_fragment' ] = "#ifdef USE_METALNESSMAP\n uniform sampler2D metalnessMap;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/morphnormal_vertex.glsl | |
| THREE.ShaderChunk[ 'morphnormal_vertex' ] = "#ifdef USE_MORPHNORMALS\n objectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n objectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n objectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n objectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/morphtarget_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'morphtarget_pars_vertex' ] = "#ifdef USE_MORPHTARGETS\n #ifndef USE_MORPHNORMALS\n uniform float morphTargetInfluences[ 8 ];\n #else\n uniform float morphTargetInfluences[ 4 ];\n #endif\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/morphtarget_vertex.glsl | |
| THREE.ShaderChunk[ 'morphtarget_vertex' ] = "#ifdef USE_MORPHTARGETS\n transformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n transformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n transformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n transformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n #ifndef USE_MORPHNORMALS\n transformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n transformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n transformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n transformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/normal_fragment.glsl | |
| THREE.ShaderChunk[ 'normal_fragment' ] = "#ifdef FLAT_SHADED\n vec3 fdx = dFdx( vViewPosition );\n vec3 fdy = dFdy( vViewPosition );\n vec3 normal = normalize( cross( fdx, fdy ) );\n#else\n vec3 normal = normalize( vNormal );\n #ifdef DOUBLE_SIDED\n normal = normal * ( -1.0 + 2.0 * float( gl_FrontFacing ) );\n #endif\n#endif\n#ifdef USE_NORMALMAP\n normal = perturbNormal2Arb( -vViewPosition, normal );\n#elif defined( USE_BUMPMAP )\n normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/normalmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'normalmap_pars_fragment' ] = "#ifdef USE_NORMALMAP\n uniform sampler2D normalMap;\n uniform vec2 normalScale;\n vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {\n vec3 q0 = dFdx( eye_pos.xyz );\n vec3 q1 = dFdy( eye_pos.xyz );\n vec2 st0 = dFdx( vUv.st );\n vec2 st1 = dFdy( vUv.st );\n vec3 S = normalize( q0 * st1.t - q1 * st0.t );\n vec3 T = normalize( -q0 * st1.s + q1 * st0.s );\n vec3 N = normalize( surf_norm );\n vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n mapN.xy = normalScale * mapN.xy;\n mat3 tsn = mat3( S, T, N );\n return normalize( tsn * mapN );\n }\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/project_vertex.glsl | |
| THREE.ShaderChunk[ 'project_vertex' ] = "#ifdef USE_SKINNING\n vec4 mvPosition = modelViewMatrix * skinned;\n#else\n vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\n#endif\ngl_Position = projectionMatrix * mvPosition;\n"; | |
| // File:src/renderers/shaders/ShaderChunk/roughnessmap_fragment.glsl | |
| THREE.ShaderChunk[ 'roughnessmap_fragment' ] = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n vec4 texelRoughness = texture2D( roughnessMap, vUv );\n roughnessFactor *= texelRoughness.r;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/roughnessmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'roughnessmap_pars_fragment' ] = "#ifdef USE_ROUGHNESSMAP\n uniform sampler2D roughnessMap;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/shadowmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'shadowmap_pars_fragment' ] = "#ifdef USE_SHADOWMAP\n #if NUM_DIR_LIGHTS > 0\n uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHTS ];\n varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n #endif\n #if NUM_SPOT_LIGHTS > 0\n uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHTS ];\n varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n #endif\n #if NUM_POINT_LIGHTS > 0\n uniform sampler2D pointShadowMap[ NUM_POINT_LIGHTS ];\n varying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n #endif\n float unpackDepth( const in vec4 rgba_depth ) {\n const vec4 bit_shift = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );\n return dot( rgba_depth, bit_shift );\n }\n float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n return step( compare, unpackDepth( texture2D( depths, uv ) ) );\n }\n float texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n const vec2 offset = vec2( 0.0, 1.0 );\n vec2 texelSize = vec2( 1.0 ) / size;\n vec2 centroidUV = floor( uv * size + 0.5 ) / size;\n float lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n float lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n float rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n float rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n vec2 f = fract( uv * size + 0.5 );\n float a = mix( lb, lt, f.y );\n float b = mix( rb, rt, f.y );\n float c = mix( a, b, f.x );\n return c;\n }\n float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n shadowCoord.xyz /= shadowCoord.w;\n shadowCoord.z += shadowBias;\n bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n bool inFrustum = all( inFrustumVec );\n bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n bool frustumTest = all( frustumTestVec );\n if ( frustumTest ) {\n #if defined( SHADOWMAP_TYPE_PCF )\n vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n float dx0 = - texelSize.x * shadowRadius;\n float dy0 = - texelSize.y * shadowRadius;\n float dx1 = + texelSize.x * shadowRadius;\n float dy1 = + texelSize.y * shadowRadius;\n return (\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n ) * ( 1.0 / 9.0 );\n #elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n float dx0 = - texelSize.x * shadowRadius;\n float dy0 = - texelSize.y * shadowRadius;\n float dx1 = + texelSize.x * shadowRadius;\n float dy1 = + texelSize.y * shadowRadius;\n return (\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n ) * ( 1.0 / 9.0 );\n #else\n return texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n #endif\n }\n return 1.0;\n }\n vec2 cubeToUV( vec3 v, float texelSizeY ) {\n vec3 absV = abs( v );\n float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n absV *= scaleToCube;\n v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n vec2 planar = v.xy;\n float almostATexel = 1.5 * texelSizeY;\n float almostOne = 1.0 - almostATexel;\n if ( absV.z >= almostOne ) {\n if ( v.z > 0.0 )\n planar.x = 4.0 - v.x;\n } else if ( absV.x >= almostOne ) {\n float signX = sign( v.x );\n planar.x = v.z * signX + 2.0 * signX;\n } else if ( absV.y >= almostOne ) {\n float signY = sign( v.y );\n planar.x = v.x + 2.0 * signY + 2.0;\n planar.y = v.z * signY - 2.0;\n }\n return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n }\n float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n vec3 lightToPosition = shadowCoord.xyz;\n vec3 bd3D = normalize( lightToPosition );\n float dp = ( length( lightToPosition ) - shadowBias ) / 1000.0;\n #if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT )\n vec3 offset = vec3( - 1, 0, 1 ) * shadowRadius * 2.0 * texelSize.y;\n return (\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zzz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zxz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xzz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zzx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zxx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xzx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zzy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zxy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xzy, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zyz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.zyx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yzz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxz, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp ) +\n texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yzx, texelSize.y ), dp )\n ) * ( 1.0 / 21.0 );\n #else\n return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n #endif\n }\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/shadowmap_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'shadowmap_pars_vertex' ] = "#ifdef USE_SHADOWMAP\n #if NUM_DIR_LIGHTS > 0\n uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHTS ];\n varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n #endif\n #if NUM_SPOT_LIGHTS > 0\n uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHTS ];\n varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n #endif\n #if NUM_POINT_LIGHTS > 0\n uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHTS ];\n varying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/shadowmap_vertex.glsl | |
| THREE.ShaderChunk[ 'shadowmap_vertex' ] = "#ifdef USE_SHADOWMAP\n #if NUM_DIR_LIGHTS > 0\n for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\n }\n #endif\n #if NUM_SPOT_LIGHTS > 0\n for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\n }\n #endif\n #if NUM_POINT_LIGHTS > 0\n for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\n }\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/shadowmask_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'shadowmask_pars_fragment' ] = "float getShadowMask() {\n float shadow = 1.0;\n #ifdef USE_SHADOWMAP\n #if NUM_DIR_LIGHTS > 0\n DirectionalLight directionalLight;\n for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n directionalLight = directionalLights[ i ];\n shadow *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n }\n #endif\n #if NUM_SPOT_LIGHTS > 0\n SpotLight spotLight;\n for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n spotLight = spotLights[ i ];\n shadow *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n }\n #endif\n #if NUM_POINT_LIGHTS > 0\n PointLight pointLight;\n for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n pointLight = pointLights[ i ];\n shadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n }\n #endif\n #endif\n return shadow;\n}\n"; | |
| // File:src/renderers/shaders/ShaderChunk/skinbase_vertex.glsl | |
| THREE.ShaderChunk[ 'skinbase_vertex' ] = "#ifdef USE_SKINNING\n mat4 boneMatX = getBoneMatrix( skinIndex.x );\n mat4 boneMatY = getBoneMatrix( skinIndex.y );\n mat4 boneMatZ = getBoneMatrix( skinIndex.z );\n mat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/skinning_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'skinning_pars_vertex' ] = "#ifdef USE_SKINNING\n uniform mat4 bindMatrix;\n uniform mat4 bindMatrixInverse;\n #ifdef BONE_TEXTURE\n uniform sampler2D boneTexture;\n uniform int boneTextureWidth;\n uniform int boneTextureHeight;\n mat4 getBoneMatrix( const in float i ) {\n float j = i * 4.0;\n float x = mod( j, float( boneTextureWidth ) );\n float y = floor( j / float( boneTextureWidth ) );\n float dx = 1.0 / float( boneTextureWidth );\n float dy = 1.0 / float( boneTextureHeight );\n y = dy * ( y + 0.5 );\n vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n mat4 bone = mat4( v1, v2, v3, v4 );\n return bone;\n }\n #else\n uniform mat4 boneGlobalMatrices[ MAX_BONES ];\n mat4 getBoneMatrix( const in float i ) {\n mat4 bone = boneGlobalMatrices[ int(i) ];\n return bone;\n }\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/skinning_vertex.glsl | |
| THREE.ShaderChunk[ 'skinning_vertex' ] = "#ifdef USE_SKINNING\n vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n vec4 skinned = vec4( 0.0 );\n skinned += boneMatX * skinVertex * skinWeight.x;\n skinned += boneMatY * skinVertex * skinWeight.y;\n skinned += boneMatZ * skinVertex * skinWeight.z;\n skinned += boneMatW * skinVertex * skinWeight.w;\n skinned = bindMatrixInverse * skinned;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/skinnormal_vertex.glsl | |
| THREE.ShaderChunk[ 'skinnormal_vertex' ] = "#ifdef USE_SKINNING\n mat4 skinMatrix = mat4( 0.0 );\n skinMatrix += skinWeight.x * boneMatX;\n skinMatrix += skinWeight.y * boneMatY;\n skinMatrix += skinWeight.z * boneMatZ;\n skinMatrix += skinWeight.w * boneMatW;\n skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\n objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/specularmap_fragment.glsl | |
| THREE.ShaderChunk[ 'specularmap_fragment' ] = "float specularStrength;\n#ifdef USE_SPECULARMAP\n vec4 texelSpecular = texture2D( specularMap, vUv );\n specularStrength = texelSpecular.r;\n#else\n specularStrength = 1.0;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/specularmap_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'specularmap_pars_fragment' ] = "#ifdef USE_SPECULARMAP\n uniform sampler2D specularMap;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/uv2_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'uv2_pars_fragment' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n varying vec2 vUv2;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/uv2_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'uv2_pars_vertex' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n attribute vec2 uv2;\n varying vec2 vUv2;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/uv2_vertex.glsl | |
| THREE.ShaderChunk[ 'uv2_vertex' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n vUv2 = uv2;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/uv_pars_fragment.glsl | |
| THREE.ShaderChunk[ 'uv_pars_fragment' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n varying vec2 vUv;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/uv_pars_vertex.glsl | |
| THREE.ShaderChunk[ 'uv_pars_vertex' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n varying vec2 vUv;\n uniform vec4 offsetRepeat;\n#endif\n"; | |
| // File:src/renderers/shaders/ShaderChunk/uv_vertex.glsl | |
| THREE.ShaderChunk[ 'uv_vertex' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n vUv = uv * offsetRepeat.zw + offsetRepeat.xy;\n#endif"; | |
| // File:src/renderers/shaders/ShaderChunk/worldpos_vertex.glsl | |
| THREE.ShaderChunk[ 'worldpos_vertex' ] = "#if defined( USE_ENVMAP ) || defined( PHONG ) || defined( STANDARD ) || defined( LAMBERT ) || defined ( USE_SHADOWMAP )\n #ifdef USE_SKINNING\n vec4 worldPosition = modelMatrix * skinned;\n #else\n vec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\n #endif\n#endif\n"; | |
| // File:src/renderers/shaders/UniformsUtils.js | |
| /** | |
| * Uniform Utilities | |
| */ | |
| THREE.UniformsUtils = { | |
| merge: function ( uniforms ) { | |
| var merged = {}; | |
| for ( var u = 0; u < uniforms.length; u ++ ) { | |
| var tmp = this.clone( uniforms[ u ] ); | |
| for ( var p in tmp ) { | |
| merged[ p ] = tmp[ p ]; | |
| } | |
| } | |
| return merged; | |
| }, | |
| clone: function ( uniforms_src ) { | |
| var uniforms_dst = {}; | |
| for ( var u in uniforms_src ) { | |
| uniforms_dst[ u ] = {}; | |
| for ( var p in uniforms_src[ u ] ) { | |
| var parameter_src = uniforms_src[ u ][ p ]; | |
| if ( parameter_src instanceof THREE.Color || | |
| parameter_src instanceof THREE.Vector2 || | |
| parameter_src instanceof THREE.Vector3 || | |
| parameter_src instanceof THREE.Vector4 || | |
| parameter_src instanceof THREE.Matrix3 || | |
| parameter_src instanceof THREE.Matrix4 || | |
| parameter_src instanceof THREE.Texture ) { | |
| uniforms_dst[ u ][ p ] = parameter_src.clone(); | |
| } else if ( Array.isArray( parameter_src ) ) { | |
| uniforms_dst[ u ][ p ] = parameter_src.slice(); | |
| } else { | |
| uniforms_dst[ u ][ p ] = parameter_src; | |
| } | |
| } | |
| } | |
| return uniforms_dst; | |
| } | |
| }; | |
| // File:src/renderers/shaders/UniformsLib.js | |
| /** | |
| * Uniforms library for shared webgl shaders | |
| */ | |
| THREE.UniformsLib = { | |
| common: { | |
| "diffuse": { type: "c", value: new THREE.Color( 0xeeeeee ) }, | |
| "opacity": { type: "f", value: 1.0 }, | |
| "map": { type: "t", value: null }, | |
| "offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) }, | |
| "specularMap": { type: "t", value: null }, | |
| "alphaMap": { type: "t", value: null }, | |
| "envMap": { type: "t", value: null }, | |
| "flipEnvMap": { type: "f", value: - 1 }, | |
| "reflectivity": { type: "f", value: 1.0 }, | |
| "refractionRatio": { type: "f", value: 0.98 } | |
| }, | |
| aomap: { | |
| "aoMap": { type: "t", value: null }, | |
| "aoMapIntensity": { type: "f", value: 1 } | |
| }, | |
| lightmap: { | |
| "lightMap": { type: "t", value: null }, | |
| "lightMapIntensity": { type: "f", value: 1 } | |
| }, | |
| emissivemap: { | |
| "emissiveMap": { type: "t", value: null } | |
| }, | |
| bumpmap: { | |
| "bumpMap": { type: "t", value: null }, | |
| "bumpScale": { type: "f", value: 1 } | |
| }, | |
| normalmap: { | |
| "normalMap": { type: "t", value: null }, | |
| "normalScale": { type: "v2", value: new THREE.Vector2( 1, 1 ) } | |
| }, | |
| displacementmap: { | |
| "displacementMap": { type: "t", value: null }, | |
| "displacementScale": { type: "f", value: 1 }, | |
| "displacementBias": { type: "f", value: 0 } | |
| }, | |
| roughnessmap: { | |
| "roughnessMap": { type: "t", value: null } | |
| }, | |
| metalnessmap: { | |
| "metalnessMap": { type: "t", value: null } | |
| }, | |
| fog: { | |
| "fogDensity": { type: "f", value: 0.00025 }, | |
| "fogNear": { type: "f", value: 1 }, | |
| "fogFar": { type: "f", value: 2000 }, | |
| "fogColor": { type: "c", value: new THREE.Color( 0xffffff ) } | |
| }, | |
| ambient: { | |
| "ambientLightColor": { type: "fv", value: [] } | |
| }, | |
| lights: { | |
| "directionalLights": { type: "sa", value: [], properties: { | |
| "direction": { type: "v3" }, | |
| "color": { type: "c" }, | |
| "shadow": { type: "i" }, | |
| "shadowBias": { type: "f" }, | |
| "shadowRadius": { type: "f" }, | |
| "shadowMapSize": { type: "v2" } | |
| } }, | |
| "directionalShadowMap": { type: "tv", value: [] }, | |
| "directionalShadowMatrix": { type: "m4v", value: [] }, | |
| "spotLights": { type: "sa", value: [], properties: { | |
| "color": { type: "c" }, | |
| "position": { type: "v3" }, | |
| "direction": { type: "v3" }, | |
| "distance": { type: "f" }, | |
| "angleCos": { type: "f" }, | |
| "exponent": { type: "f" }, | |
| "decay": { type: "f" }, | |
| "shadow": { type: "i" }, | |
| "shadowBias": { type: "f" }, | |
| "shadowRadius": { type: "f" }, | |
| "shadowMapSize": { type: "v2" } | |
| } }, | |
| "spotShadowMap": { type: "tv", value: [] }, | |
| "spotShadowMatrix": { type: "m4v", value: [] }, | |
| "pointLights": { type: "sa", value: [], properties: { | |
| "color": { type: "c" }, | |
| "position": { type: "v3" }, | |
| "decay": { type: "f" }, | |
| "distance": { type: "f" }, | |
| "shadow": { type: "i" }, | |
| "shadowBias": { type: "f" }, | |
| "shadowRadius": { type: "f" }, | |
| "shadowMapSize": { type: "v2" } | |
| } }, | |
| "pointShadowMap": { type: "tv", value: [] }, | |
| "pointShadowMatrix": { type: "m4v", value: [] }, | |
| "hemisphereLights": { type: "sa", value: [], properties: { | |
| "direction": { type: "v3" }, | |
| "skyColor": { type: "c" }, | |
| "groundColor": { type: "c" } | |
| } } | |
| }, | |
| points: { | |
| "diffuse": { type: "c", value: new THREE.Color( 0xeeeeee ) }, | |
| "opacity": { type: "f", value: 1.0 }, | |
| "size": { type: "f", value: 1.0 }, | |
| "scale": { type: "f", value: 1.0 }, | |
| "map": { type: "t", value: null }, | |
| "offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) } | |
| } | |
| }; | |
| // File:src/renderers/shaders/ShaderLib.js | |
| /** | |
| * Webgl Shader Library for three.js | |
| * | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author mikael emtinger / http://gomo.se/ | |
| */ | |
| THREE.ShaderLib = { | |
| 'basic': { | |
| uniforms: THREE.UniformsUtils.merge( [ | |
| THREE.UniformsLib[ "common" ], | |
| THREE.UniformsLib[ "aomap" ], | |
| THREE.UniformsLib[ "fog" ] | |
| ] ), | |
| vertexShader: [ | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "uv_pars_vertex" ], | |
| THREE.ShaderChunk[ "uv2_pars_vertex" ], | |
| THREE.ShaderChunk[ "envmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "color_pars_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "skinning_pars_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "uv_vertex" ], | |
| THREE.ShaderChunk[ "uv2_vertex" ], | |
| THREE.ShaderChunk[ "color_vertex" ], | |
| THREE.ShaderChunk[ "skinbase_vertex" ], | |
| " #ifdef USE_ENVMAP", | |
| THREE.ShaderChunk[ "beginnormal_vertex" ], | |
| THREE.ShaderChunk[ "morphnormal_vertex" ], | |
| THREE.ShaderChunk[ "skinnormal_vertex" ], | |
| THREE.ShaderChunk[ "defaultnormal_vertex" ], | |
| " #endif", | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "skinning_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| THREE.ShaderChunk[ "worldpos_vertex" ], | |
| THREE.ShaderChunk[ "envmap_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform vec3 diffuse;", | |
| "uniform float opacity;", | |
| "#ifndef FLAT_SHADED", | |
| " varying vec3 vNormal;", | |
| "#endif", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv2_pars_fragment" ], | |
| THREE.ShaderChunk[ "map_pars_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_pars_fragment" ], | |
| THREE.ShaderChunk[ "aomap_pars_fragment" ], | |
| THREE.ShaderChunk[ "envmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "fog_pars_fragment" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "specularmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " vec4 diffuseColor = vec4( diffuse, opacity );", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| THREE.ShaderChunk[ "map_fragment" ], | |
| THREE.ShaderChunk[ "color_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_fragment" ], | |
| THREE.ShaderChunk[ "alphatest_fragment" ], | |
| THREE.ShaderChunk[ "specularmap_fragment" ], | |
| " ReflectedLight reflectedLight;", | |
| " reflectedLight.directDiffuse = vec3( 0.0 );", | |
| " reflectedLight.directSpecular = vec3( 0.0 );", | |
| " reflectedLight.indirectDiffuse = diffuseColor.rgb;", | |
| " reflectedLight.indirectSpecular = vec3( 0.0 );", | |
| THREE.ShaderChunk[ "aomap_fragment" ], | |
| " vec3 outgoingLight = reflectedLight.indirectDiffuse;", | |
| THREE.ShaderChunk[ "envmap_fragment" ], | |
| THREE.ShaderChunk[ "linear_to_gamma_fragment" ], | |
| THREE.ShaderChunk[ "fog_fragment" ], | |
| " gl_FragColor = vec4( outgoingLight, diffuseColor.a );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'lambert': { | |
| uniforms: THREE.UniformsUtils.merge( [ | |
| THREE.UniformsLib[ "common" ], | |
| THREE.UniformsLib[ "aomap" ], | |
| THREE.UniformsLib[ "lightmap" ], | |
| THREE.UniformsLib[ "emissivemap" ], | |
| THREE.UniformsLib[ "fog" ], | |
| THREE.UniformsLib[ "ambient" ], | |
| THREE.UniformsLib[ "lights" ], | |
| { | |
| "emissive" : { type: "c", value: new THREE.Color( 0x000000 ) } | |
| } | |
| ] ), | |
| vertexShader: [ | |
| "#define LAMBERT", | |
| "varying vec3 vLightFront;", | |
| "#ifdef DOUBLE_SIDED", | |
| " varying vec3 vLightBack;", | |
| "#endif", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "uv_pars_vertex" ], | |
| THREE.ShaderChunk[ "uv2_pars_vertex" ], | |
| THREE.ShaderChunk[ "envmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "bsdfs" ], | |
| THREE.ShaderChunk[ "lights_pars" ], | |
| THREE.ShaderChunk[ "color_pars_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "skinning_pars_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "uv_vertex" ], | |
| THREE.ShaderChunk[ "uv2_vertex" ], | |
| THREE.ShaderChunk[ "color_vertex" ], | |
| THREE.ShaderChunk[ "beginnormal_vertex" ], | |
| THREE.ShaderChunk[ "morphnormal_vertex" ], | |
| THREE.ShaderChunk[ "skinbase_vertex" ], | |
| THREE.ShaderChunk[ "skinnormal_vertex" ], | |
| THREE.ShaderChunk[ "defaultnormal_vertex" ], | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "skinning_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| THREE.ShaderChunk[ "worldpos_vertex" ], | |
| THREE.ShaderChunk[ "envmap_vertex" ], | |
| THREE.ShaderChunk[ "lights_lambert_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform vec3 diffuse;", | |
| "uniform vec3 emissive;", | |
| "uniform float opacity;", | |
| "varying vec3 vLightFront;", | |
| "#ifdef DOUBLE_SIDED", | |
| " varying vec3 vLightBack;", | |
| "#endif", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv2_pars_fragment" ], | |
| THREE.ShaderChunk[ "map_pars_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_pars_fragment" ], | |
| THREE.ShaderChunk[ "aomap_pars_fragment" ], | |
| THREE.ShaderChunk[ "lightmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "emissivemap_pars_fragment" ], | |
| THREE.ShaderChunk[ "envmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "bsdfs" ], | |
| THREE.ShaderChunk[ "ambient_pars" ], | |
| THREE.ShaderChunk[ "lights_pars" ], | |
| THREE.ShaderChunk[ "fog_pars_fragment" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "shadowmask_pars_fragment" ], | |
| THREE.ShaderChunk[ "specularmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " vec4 diffuseColor = vec4( diffuse, opacity );", | |
| " ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );", | |
| " vec3 totalEmissiveLight = emissive;", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| THREE.ShaderChunk[ "map_fragment" ], | |
| THREE.ShaderChunk[ "color_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_fragment" ], | |
| THREE.ShaderChunk[ "alphatest_fragment" ], | |
| THREE.ShaderChunk[ "specularmap_fragment" ], | |
| THREE.ShaderChunk[ "emissivemap_fragment" ], | |
| // accumulation | |
| " reflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );", | |
| THREE.ShaderChunk[ "lightmap_fragment" ], | |
| " reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );", | |
| " #ifdef DOUBLE_SIDED", | |
| " reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;", | |
| " #else", | |
| " reflectedLight.directDiffuse = vLightFront;", | |
| " #endif", | |
| " reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();", | |
| // modulation | |
| THREE.ShaderChunk[ "aomap_fragment" ], | |
| " vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveLight;", | |
| THREE.ShaderChunk[ "envmap_fragment" ], | |
| THREE.ShaderChunk[ "linear_to_gamma_fragment" ], | |
| THREE.ShaderChunk[ "fog_fragment" ], | |
| " gl_FragColor = vec4( outgoingLight, diffuseColor.a );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'phong': { | |
| uniforms: THREE.UniformsUtils.merge( [ | |
| THREE.UniformsLib[ "common" ], | |
| THREE.UniformsLib[ "aomap" ], | |
| THREE.UniformsLib[ "lightmap" ], | |
| THREE.UniformsLib[ "emissivemap" ], | |
| THREE.UniformsLib[ "bumpmap" ], | |
| THREE.UniformsLib[ "normalmap" ], | |
| THREE.UniformsLib[ "displacementmap" ], | |
| THREE.UniformsLib[ "fog" ], | |
| THREE.UniformsLib[ "ambient" ], | |
| THREE.UniformsLib[ "lights" ], | |
| { | |
| "emissive" : { type: "c", value: new THREE.Color( 0x000000 ) }, | |
| "specular" : { type: "c", value: new THREE.Color( 0x111111 ) }, | |
| "shininess": { type: "f", value: 30 } | |
| } | |
| ] ), | |
| vertexShader: [ | |
| "#define PHONG", | |
| "varying vec3 vViewPosition;", | |
| "#ifndef FLAT_SHADED", | |
| " varying vec3 vNormal;", | |
| "#endif", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "uv_pars_vertex" ], | |
| THREE.ShaderChunk[ "uv2_pars_vertex" ], | |
| THREE.ShaderChunk[ "displacementmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "envmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "lights_phong_pars_vertex" ], | |
| THREE.ShaderChunk[ "color_pars_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "skinning_pars_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "uv_vertex" ], | |
| THREE.ShaderChunk[ "uv2_vertex" ], | |
| THREE.ShaderChunk[ "color_vertex" ], | |
| THREE.ShaderChunk[ "beginnormal_vertex" ], | |
| THREE.ShaderChunk[ "morphnormal_vertex" ], | |
| THREE.ShaderChunk[ "skinbase_vertex" ], | |
| THREE.ShaderChunk[ "skinnormal_vertex" ], | |
| THREE.ShaderChunk[ "defaultnormal_vertex" ], | |
| "#ifndef FLAT_SHADED", // Normal computed with derivatives when FLAT_SHADED | |
| " vNormal = normalize( transformedNormal );", | |
| "#endif", | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "displacementmap_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "skinning_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| " vViewPosition = - mvPosition.xyz;", | |
| THREE.ShaderChunk[ "worldpos_vertex" ], | |
| THREE.ShaderChunk[ "envmap_vertex" ], | |
| THREE.ShaderChunk[ "lights_phong_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "#define PHONG", | |
| "uniform vec3 diffuse;", | |
| "uniform vec3 emissive;", | |
| "uniform vec3 specular;", | |
| "uniform float shininess;", | |
| "uniform float opacity;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv2_pars_fragment" ], | |
| THREE.ShaderChunk[ "map_pars_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_pars_fragment" ], | |
| THREE.ShaderChunk[ "aomap_pars_fragment" ], | |
| THREE.ShaderChunk[ "lightmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "emissivemap_pars_fragment" ], | |
| THREE.ShaderChunk[ "envmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "fog_pars_fragment" ], | |
| THREE.ShaderChunk[ "bsdfs" ], | |
| THREE.ShaderChunk[ "ambient_pars" ], | |
| THREE.ShaderChunk[ "lights_pars" ], | |
| THREE.ShaderChunk[ "lights_phong_pars_fragment" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "bumpmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "normalmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "specularmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " vec4 diffuseColor = vec4( diffuse, opacity );", | |
| " ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );", | |
| " vec3 totalEmissiveLight = emissive;", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| THREE.ShaderChunk[ "map_fragment" ], | |
| THREE.ShaderChunk[ "color_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_fragment" ], | |
| THREE.ShaderChunk[ "alphatest_fragment" ], | |
| THREE.ShaderChunk[ "specularmap_fragment" ], | |
| THREE.ShaderChunk[ "normal_fragment" ], | |
| THREE.ShaderChunk[ "emissivemap_fragment" ], | |
| // accumulation | |
| THREE.ShaderChunk[ "lights_phong_fragment" ], | |
| THREE.ShaderChunk[ "lights_template" ], | |
| // modulation | |
| THREE.ShaderChunk[ "aomap_fragment" ], | |
| "vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveLight;", | |
| THREE.ShaderChunk[ "envmap_fragment" ], | |
| THREE.ShaderChunk[ "linear_to_gamma_fragment" ], | |
| THREE.ShaderChunk[ "fog_fragment" ], | |
| " gl_FragColor = vec4( outgoingLight, diffuseColor.a );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'standard': { | |
| uniforms: THREE.UniformsUtils.merge( [ | |
| THREE.UniformsLib[ "common" ], | |
| THREE.UniformsLib[ "aomap" ], | |
| THREE.UniformsLib[ "lightmap" ], | |
| THREE.UniformsLib[ "emissivemap" ], | |
| THREE.UniformsLib[ "bumpmap" ], | |
| THREE.UniformsLib[ "normalmap" ], | |
| THREE.UniformsLib[ "displacementmap" ], | |
| THREE.UniformsLib[ "roughnessmap" ], | |
| THREE.UniformsLib[ "metalnessmap" ], | |
| THREE.UniformsLib[ "fog" ], | |
| THREE.UniformsLib[ "ambient" ], | |
| THREE.UniformsLib[ "lights" ], | |
| { | |
| "emissive" : { type: "c", value: new THREE.Color( 0x000000 ) }, | |
| "roughness": { type: "f", value: 0.5 }, | |
| "metalness": { type: "f", value: 0 }, | |
| "envMapIntensity" : { type: "f", value: 1 } // temporary | |
| } | |
| ] ), | |
| vertexShader: [ | |
| "#define STANDARD", | |
| "varying vec3 vViewPosition;", | |
| "#ifndef FLAT_SHADED", | |
| " varying vec3 vNormal;", | |
| "#endif", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "uv_pars_vertex" ], | |
| THREE.ShaderChunk[ "uv2_pars_vertex" ], | |
| THREE.ShaderChunk[ "displacementmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "envmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "color_pars_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "skinning_pars_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "specularmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", // STANDARD | |
| THREE.ShaderChunk[ "uv_vertex" ], | |
| THREE.ShaderChunk[ "uv2_vertex" ], | |
| THREE.ShaderChunk[ "color_vertex" ], | |
| THREE.ShaderChunk[ "beginnormal_vertex" ], | |
| THREE.ShaderChunk[ "morphnormal_vertex" ], | |
| THREE.ShaderChunk[ "skinbase_vertex" ], | |
| THREE.ShaderChunk[ "skinnormal_vertex" ], | |
| THREE.ShaderChunk[ "defaultnormal_vertex" ], | |
| "#ifndef FLAT_SHADED", // Normal computed with derivatives when FLAT_SHADED | |
| " vNormal = normalize( transformedNormal );", | |
| "#endif", | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "displacementmap_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "skinning_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| " vViewPosition = - mvPosition.xyz;", | |
| THREE.ShaderChunk[ "worldpos_vertex" ], | |
| THREE.ShaderChunk[ "envmap_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "#define STANDARD", | |
| "uniform vec3 diffuse;", | |
| "uniform vec3 emissive;", | |
| "uniform float roughness;", | |
| "uniform float metalness;", | |
| "uniform float opacity;", | |
| "uniform float envMapIntensity;", // temporary | |
| "varying vec3 vViewPosition;", | |
| "#ifndef FLAT_SHADED", | |
| " varying vec3 vNormal;", | |
| "#endif", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv_pars_fragment" ], | |
| THREE.ShaderChunk[ "uv2_pars_fragment" ], | |
| THREE.ShaderChunk[ "map_pars_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_pars_fragment" ], | |
| THREE.ShaderChunk[ "aomap_pars_fragment" ], | |
| THREE.ShaderChunk[ "lightmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "emissivemap_pars_fragment" ], | |
| THREE.ShaderChunk[ "envmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "fog_pars_fragment" ], | |
| THREE.ShaderChunk[ "bsdfs" ], | |
| THREE.ShaderChunk[ "ambient_pars" ], | |
| THREE.ShaderChunk[ "lights_pars" ], | |
| THREE.ShaderChunk[ "lights_standard_pars_fragment" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "bumpmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "normalmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "roughnessmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "metalnessmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " vec4 diffuseColor = vec4( diffuse, opacity );", | |
| " ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );", | |
| " vec3 totalEmissiveLight = emissive;", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| THREE.ShaderChunk[ "map_fragment" ], | |
| THREE.ShaderChunk[ "color_fragment" ], | |
| THREE.ShaderChunk[ "alphamap_fragment" ], | |
| THREE.ShaderChunk[ "alphatest_fragment" ], | |
| THREE.ShaderChunk[ "specularmap_fragment" ], | |
| THREE.ShaderChunk[ "roughnessmap_fragment" ], | |
| THREE.ShaderChunk[ "metalnessmap_fragment" ], | |
| THREE.ShaderChunk[ "normal_fragment" ], | |
| THREE.ShaderChunk[ "emissivemap_fragment" ], | |
| // accumulation | |
| THREE.ShaderChunk[ "lights_standard_fragment" ], | |
| THREE.ShaderChunk[ "lights_template" ], | |
| // modulation | |
| THREE.ShaderChunk[ "aomap_fragment" ], | |
| "vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveLight;", | |
| THREE.ShaderChunk[ "linear_to_gamma_fragment" ], | |
| THREE.ShaderChunk[ "fog_fragment" ], | |
| " gl_FragColor = vec4( outgoingLight, diffuseColor.a );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'points': { | |
| uniforms: THREE.UniformsUtils.merge( [ | |
| THREE.UniformsLib[ "points" ], | |
| THREE.UniformsLib[ "fog" ] | |
| ] ), | |
| vertexShader: [ | |
| "uniform float size;", | |
| "uniform float scale;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "color_vertex" ], | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| " #ifdef USE_SIZEATTENUATION", | |
| " gl_PointSize = size * ( scale / - mvPosition.z );", | |
| " #else", | |
| " gl_PointSize = size;", | |
| " #endif", | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| THREE.ShaderChunk[ "worldpos_vertex" ], | |
| THREE.ShaderChunk[ "shadowmap_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform vec3 diffuse;", | |
| "uniform float opacity;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_fragment" ], | |
| THREE.ShaderChunk[ "map_particle_pars_fragment" ], | |
| THREE.ShaderChunk[ "fog_pars_fragment" ], | |
| THREE.ShaderChunk[ "shadowmap_pars_fragment" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " vec3 outgoingLight = vec3( 0.0 );", | |
| " vec4 diffuseColor = vec4( diffuse, opacity );", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| THREE.ShaderChunk[ "map_particle_fragment" ], | |
| THREE.ShaderChunk[ "color_fragment" ], | |
| THREE.ShaderChunk[ "alphatest_fragment" ], | |
| " outgoingLight = diffuseColor.rgb;", | |
| THREE.ShaderChunk[ "fog_fragment" ], | |
| " gl_FragColor = vec4( outgoingLight, diffuseColor.a );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'dashed': { | |
| uniforms: THREE.UniformsUtils.merge( [ | |
| THREE.UniformsLib[ "common" ], | |
| THREE.UniformsLib[ "fog" ], | |
| { | |
| "scale" : { type: "f", value: 1 }, | |
| "dashSize" : { type: "f", value: 1 }, | |
| "totalSize": { type: "f", value: 2 } | |
| } | |
| ] ), | |
| vertexShader: [ | |
| "uniform float scale;", | |
| "attribute float lineDistance;", | |
| "varying float vLineDistance;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "color_vertex" ], | |
| " vLineDistance = scale * lineDistance;", | |
| " vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", | |
| " gl_Position = projectionMatrix * mvPosition;", | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform vec3 diffuse;", | |
| "uniform float opacity;", | |
| "uniform float dashSize;", | |
| "uniform float totalSize;", | |
| "varying float vLineDistance;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "color_pars_fragment" ], | |
| THREE.ShaderChunk[ "fog_pars_fragment" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " if ( mod( vLineDistance, totalSize ) > dashSize ) {", | |
| " discard;", | |
| " }", | |
| " vec3 outgoingLight = vec3( 0.0 );", | |
| " vec4 diffuseColor = vec4( diffuse, opacity );", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| THREE.ShaderChunk[ "color_fragment" ], | |
| " outgoingLight = diffuseColor.rgb;", // simple shader | |
| THREE.ShaderChunk[ "fog_fragment" ], | |
| " gl_FragColor = vec4( outgoingLight, diffuseColor.a );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'depth': { | |
| uniforms: { | |
| "mNear": { type: "f", value: 1.0 }, | |
| "mFar" : { type: "f", value: 2000.0 }, | |
| "opacity" : { type: "f", value: 1.0 } | |
| }, | |
| vertexShader: [ | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform float mNear;", | |
| "uniform float mFar;", | |
| "uniform float opacity;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| " #ifdef USE_LOGDEPTHBUF_EXT", | |
| " float depth = gl_FragDepthEXT / gl_FragCoord.w;", | |
| " #else", | |
| " float depth = gl_FragCoord.z / gl_FragCoord.w;", | |
| " #endif", | |
| " float color = 1.0 - smoothstep( mNear, mFar, depth );", | |
| " gl_FragColor = vec4( vec3( color ), opacity );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'normal': { | |
| uniforms: { | |
| "opacity" : { type: "f", value: 1.0 } | |
| }, | |
| vertexShader: [ | |
| "varying vec3 vNormal;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| " vNormal = normalize( normalMatrix * normal );", | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform float opacity;", | |
| "varying vec3 vNormal;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " gl_FragColor = vec4( 0.5 * normalize( vNormal ) + 0.5, opacity );", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| /* ------------------------------------------------------------------------- | |
| // Cube map shader | |
| ------------------------------------------------------------------------- */ | |
| 'cube': { | |
| uniforms: { | |
| "tCube": { type: "t", value: null }, | |
| "tFlip": { type: "f", value: - 1 } | |
| }, | |
| vertexShader: [ | |
| "varying vec3 vWorldPosition;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| " vWorldPosition = transformDirection( position, modelMatrix );", | |
| " gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform samplerCube tCube;", | |
| "uniform float tFlip;", | |
| "varying vec3 vWorldPosition;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| " gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| /* ------------------------------------------------------------------------- | |
| // Cube map shader | |
| ------------------------------------------------------------------------- */ | |
| 'equirect': { | |
| uniforms: { | |
| "tEquirect": { type: "t", value: null }, | |
| "tFlip": { type: "f", value: - 1 } | |
| }, | |
| vertexShader: [ | |
| "varying vec3 vWorldPosition;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| " vWorldPosition = transformDirection( position, modelMatrix );", | |
| " gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform sampler2D tEquirect;", | |
| "uniform float tFlip;", | |
| "varying vec3 vWorldPosition;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "void main() {", | |
| // " gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );", | |
| "vec3 direction = normalize( vWorldPosition );", | |
| "vec2 sampleUV;", | |
| "sampleUV.y = saturate( tFlip * direction.y * -0.5 + 0.5 );", | |
| "sampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;", | |
| "gl_FragColor = texture2D( tEquirect, sampleUV );", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| /* Depth encoding into RGBA texture | |
| * | |
| * based on SpiderGL shadow map example | |
| * http://spidergl.org/example.php?id=6 | |
| * | |
| * originally from | |
| * http://www.gamedev.net/topic/442138-packing-a-float-into-a-a8r8g8b8-texture-shader/page__whichpage__1%25EF%25BF%25BD | |
| * | |
| * see also | |
| * http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/ | |
| */ | |
| 'depthRGBA': { | |
| uniforms: {}, | |
| vertexShader: [ | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "skinning_pars_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "skinbase_vertex" ], | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "skinning_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "logdepthbuf_vertex" ], | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "logdepthbuf_pars_fragment" ], | |
| "vec4 pack_depth( const in float depth ) {", | |
| " const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );", | |
| " const vec4 bit_mask = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );", | |
| " vec4 res = mod( depth * bit_shift * vec4( 255 ), vec4( 256 ) ) / vec4( 255 );", | |
| " res -= res.xxyz * bit_mask;", | |
| " return res;", | |
| "}", | |
| "void main() {", | |
| THREE.ShaderChunk[ "logdepthbuf_fragment" ], | |
| " #ifdef USE_LOGDEPTHBUF_EXT", | |
| " gl_FragData[ 0 ] = pack_depth( gl_FragDepthEXT );", | |
| " #else", | |
| " gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z );", | |
| " #endif", | |
| //"gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z / gl_FragCoord.w );", | |
| //"float z = ( ( gl_FragCoord.z / gl_FragCoord.w ) - 3.0 ) / ( 4000.0 - 3.0 );", | |
| //"gl_FragData[ 0 ] = pack_depth( z );", | |
| //"gl_FragData[ 0 ] = vec4( z, z, z, 1.0 );", | |
| "}" | |
| ].join( "\n" ) | |
| }, | |
| 'distanceRGBA': { | |
| uniforms: { | |
| "lightPos": { type: "v3", value: new THREE.Vector3( 0, 0, 0 ) } | |
| }, | |
| vertexShader: [ | |
| "varying vec4 vWorldPosition;", | |
| THREE.ShaderChunk[ "common" ], | |
| THREE.ShaderChunk[ "morphtarget_pars_vertex" ], | |
| THREE.ShaderChunk[ "skinning_pars_vertex" ], | |
| "void main() {", | |
| THREE.ShaderChunk[ "skinbase_vertex" ], | |
| THREE.ShaderChunk[ "begin_vertex" ], | |
| THREE.ShaderChunk[ "morphtarget_vertex" ], | |
| THREE.ShaderChunk[ "skinning_vertex" ], | |
| THREE.ShaderChunk[ "project_vertex" ], | |
| THREE.ShaderChunk[ "worldpos_vertex" ], | |
| "vWorldPosition = worldPosition;", | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform vec3 lightPos;", | |
| "varying vec4 vWorldPosition;", | |
| THREE.ShaderChunk[ "common" ], | |
| "vec4 pack1K ( float depth ) {", | |
| " depth /= 1000.0;", | |
| " const vec4 bitSh = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );", | |
| " const vec4 bitMsk = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );", | |
| " vec4 res = mod( depth * bitSh * vec4( 255 ), vec4( 256 ) ) / vec4( 255 );", | |
| " res -= res.xxyz * bitMsk;", | |
| " return res; ", | |
| "}", | |
| "float unpack1K ( vec4 color ) {", | |
| " const vec4 bitSh = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );", | |
| " return dot( color, bitSh ) * 1000.0;", | |
| "}", | |
| "void main () {", | |
| " gl_FragColor = pack1K( length( vWorldPosition.xyz - lightPos.xyz ) );", | |
| "}" | |
| ].join( "\n" ) | |
| } | |
| }; | |
| // File:src/renderers/WebGLRenderer.js | |
| /** | |
| * @author supereggbert / http://www.paulbrunt.co.uk/ | |
| * @author mrdoob / http://mrdoob.com/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author szimek / https://github.com/szimek/ | |
| */ | |
| THREE.WebGLRenderer = function ( parameters ) { | |
| console.log( 'THREE.WebGLRenderer', THREE.REVISION ); | |
| parameters = parameters || {}; | |
| var _canvas = parameters.canvas !== undefined ? parameters.canvas : document.createElement( 'canvas' ), | |
| _context = parameters.context !== undefined ? parameters.context : null, | |
| _alpha = parameters.alpha !== undefined ? parameters.alpha : false, | |
| _depth = parameters.depth !== undefined ? parameters.depth : true, | |
| _stencil = parameters.stencil !== undefined ? parameters.stencil : true, | |
| _antialias = parameters.antialias !== undefined ? parameters.antialias : false, | |
| _premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true, | |
| _preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false; | |
| var lights = []; | |
| var opaqueObjects = []; | |
| var opaqueObjectsLastIndex = - 1; | |
| var transparentObjects = []; | |
| var transparentObjectsLastIndex = - 1; | |
| var morphInfluences = new Float32Array( 8 ); | |
| var sprites = []; | |
| var lensFlares = []; | |
| // public properties | |
| this.domElement = _canvas; | |
| this.context = null; | |
| // clearing | |
| this.autoClear = true; | |
| this.autoClearColor = true; | |
| this.autoClearDepth = true; | |
| this.autoClearStencil = true; | |
| // scene graph | |
| this.sortObjects = true; | |
| // physically based shading | |
| this.gammaFactor = 2.0; // for backwards compatibility | |
| this.gammaInput = false; | |
| this.gammaOutput = false; | |
| // morphs | |
| this.maxMorphTargets = 8; | |
| this.maxMorphNormals = 4; | |
| // flags | |
| this.autoScaleCubemaps = true; | |
| // internal properties | |
| var _this = this, | |
| // internal state cache | |
| _currentProgram = null, | |
| _currentRenderTarget = null, | |
| _currentFramebuffer = null, | |
| _currentMaterialId = - 1, | |
| _currentGeometryProgram = '', | |
| _currentCamera = null, | |
| _currentScissor = new THREE.Vector4(), | |
| _currentScissorTest = null, | |
| _currentViewport = new THREE.Vector4(), | |
| // | |
| _usedTextureUnits = 0, | |
| // | |
| _clearColor = new THREE.Color( 0x000000 ), | |
| _clearAlpha = 0, | |
| _width = _canvas.width, | |
| _height = _canvas.height, | |
| _pixelRatio = 1, | |
| _scissor = new THREE.Vector4( 0, 0, _width, _height ), | |
| _scissorTest = false, | |
| _viewport = new THREE.Vector4( 0, 0, _width, _height ), | |
| // frustum | |
| _frustum = new THREE.Frustum(), | |
| // camera matrices cache | |
| _projScreenMatrix = new THREE.Matrix4(), | |
| _vector3 = new THREE.Vector3(), | |
| // light arrays cache | |
| _lights = { | |
| hash: '', | |
| ambient: [ 0, 0, 0 ], | |
| directional: [], | |
| directionalShadowMap: [], | |
| directionalShadowMatrix: [], | |
| spot: [], | |
| spotShadowMap: [], | |
| spotShadowMatrix: [], | |
| point: [], | |
| pointShadowMap: [], | |
| pointShadowMatrix: [], | |
| hemi: [], | |
| shadows: [], | |
| shadowsPointLight: 0 | |
| }, | |
| // info | |
| _infoMemory = { | |
| geometries: 0, | |
| textures: 0 | |
| }, | |
| _infoRender = { | |
| calls: 0, | |
| vertices: 0, | |
| faces: 0, | |
| points: 0 | |
| }; | |
| this.info = { | |
| render: _infoRender, | |
| memory: _infoMemory, | |
| programs: null | |
| }; | |
| // initialize | |
| var _gl; | |
| try { | |
| var attributes = { | |
| alpha: _alpha, | |
| depth: _depth, | |
| stencil: _stencil, | |
| antialias: _antialias, | |
| premultipliedAlpha: _premultipliedAlpha, | |
| preserveDrawingBuffer: _preserveDrawingBuffer | |
| }; | |
| _gl = _context || _canvas.getContext( 'webgl', attributes ) || _canvas.getContext( 'experimental-webgl', attributes ); | |
| if ( _gl === null ) { | |
| if ( _canvas.getContext( 'webgl' ) !== null ) { | |
| throw 'Error creating WebGL context with your selected attributes.'; | |
| } else { | |
| throw 'Error creating WebGL context.'; | |
| } | |
| } | |
| _canvas.addEventListener( 'webglcontextlost', onContextLost, false ); | |
| } catch ( error ) { | |
| console.error( 'THREE.WebGLRenderer: ' + error ); | |
| } | |
| var extensions = new THREE.WebGLExtensions( _gl ); | |
| extensions.get( 'OES_texture_float' ); | |
| extensions.get( 'OES_texture_float_linear' ); | |
| extensions.get( 'OES_texture_half_float' ); | |
| extensions.get( 'OES_texture_half_float_linear' ); | |
| extensions.get( 'OES_standard_derivatives' ); | |
| extensions.get( 'ANGLE_instanced_arrays' ); | |
| if ( extensions.get( 'OES_element_index_uint' ) ) { | |
| THREE.BufferGeometry.MaxIndex = 4294967296; | |
| } | |
| var capabilities = new THREE.WebGLCapabilities( _gl, extensions, parameters ); | |
| var state = new THREE.WebGLState( _gl, extensions, paramThreeToGL ); | |
| var properties = new THREE.WebGLProperties(); | |
| var objects = new THREE.WebGLObjects( _gl, properties, this.info ); | |
| var programCache = new THREE.WebGLPrograms( this, capabilities ); | |
| var lightCache = new THREE.WebGLLights(); | |
| this.info.programs = programCache.programs; | |
| var bufferRenderer = new THREE.WebGLBufferRenderer( _gl, extensions, _infoRender ); | |
| var indexedBufferRenderer = new THREE.WebGLIndexedBufferRenderer( _gl, extensions, _infoRender ); | |
| // | |
| function getTargetPixelRatio() { | |
| return _currentRenderTarget === null ? _pixelRatio : 1; | |
| } | |
| function glClearColor( r, g, b, a ) { | |
| if ( _premultipliedAlpha === true ) { | |
| r *= a; g *= a; b *= a; | |
| } | |
| state.clearColor( r, g, b, a ); | |
| } | |
| function setDefaultGLState() { | |
| state.init(); | |
| state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) ); | |
| state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) ); | |
| glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha ); | |
| } | |
| function resetGLState() { | |
| _currentProgram = null; | |
| _currentCamera = null; | |
| _currentGeometryProgram = ''; | |
| _currentMaterialId = - 1; | |
| state.reset(); | |
| } | |
| setDefaultGLState(); | |
| this.context = _gl; | |
| this.capabilities = capabilities; | |
| this.extensions = extensions; | |
| this.properties = properties; | |
| this.state = state; | |
| // shadow map | |
| var shadowMap = new THREE.WebGLShadowMap( this, _lights, objects ); | |
| this.shadowMap = shadowMap; | |
| // Plugins | |
| var spritePlugin = new THREE.SpritePlugin( this, sprites ); | |
| var lensFlarePlugin = new THREE.LensFlarePlugin( this, lensFlares ); | |
| // API | |
| this.getContext = function () { | |
| return _gl; | |
| }; | |
| this.getContextAttributes = function () { | |
| return _gl.getContextAttributes(); | |
| }; | |
| this.forceContextLoss = function () { | |
| extensions.get( 'WEBGL_lose_context' ).loseContext(); | |
| }; | |
| this.getMaxAnisotropy = ( function () { | |
| var value; | |
| return function getMaxAnisotropy() { | |
| if ( value !== undefined ) return value; | |
| var extension = extensions.get( 'EXT_texture_filter_anisotropic' ); | |
| if ( extension !== null ) { | |
| value = _gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT ); | |
| } else { | |
| value = 0; | |
| } | |
| return value; | |
| }; | |
| } )(); | |
| this.getPrecision = function () { | |
| return capabilities.precision; | |
| }; | |
| this.getPixelRatio = function () { | |
| return _pixelRatio; | |
| }; | |
| this.setPixelRatio = function ( value ) { | |
| if ( value === undefined ) return; | |
| _pixelRatio = value; | |
| this.setSize( _viewport.z, _viewport.w, false ); | |
| }; | |
| this.getSize = function () { | |
| return { | |
| width: _width, | |
| height: _height | |
| }; | |
| }; | |
| this.setSize = function ( width, height, updateStyle ) { | |
| _width = width; | |
| _height = height; | |
| _canvas.width = width * _pixelRatio; | |
| _canvas.height = height * _pixelRatio; | |
| if ( updateStyle !== false ) { | |
| _canvas.style.width = width + 'px'; | |
| _canvas.style.height = height + 'px'; | |
| } | |
| this.setViewport( 0, 0, width, height ); | |
| }; | |
| this.setViewport = function ( x, y, width, height ) { | |
| state.viewport( _viewport.set( x, y, width, height ) ); | |
| }; | |
| this.setScissor = function ( x, y, width, height ) { | |
| state.scissor( _scissor.set( x, y, width, height ) ); | |
| }; | |
| this.setScissorTest = function ( boolean ) { | |
| state.setScissorTest( _scissorTest = boolean ); | |
| }; | |
| // Clearing | |
| this.getClearColor = function () { | |
| return _clearColor; | |
| }; | |
| this.setClearColor = function ( color, alpha ) { | |
| _clearColor.set( color ); | |
| _clearAlpha = alpha !== undefined ? alpha : 1; | |
| glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha ); | |
| }; | |
| this.getClearAlpha = function () { | |
| return _clearAlpha; | |
| }; | |
| this.setClearAlpha = function ( alpha ) { | |
| _clearAlpha = alpha; | |
| glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha ); | |
| }; | |
| this.clear = function ( color, depth, stencil ) { | |
| var bits = 0; | |
| if ( color === undefined || color ) bits |= _gl.COLOR_BUFFER_BIT; | |
| if ( depth === undefined || depth ) bits |= _gl.DEPTH_BUFFER_BIT; | |
| if ( stencil === undefined || stencil ) bits |= _gl.STENCIL_BUFFER_BIT; | |
| _gl.clear( bits ); | |
| }; | |
| this.clearColor = function () { | |
| this.clear( true, false, false ); | |
| }; | |
| this.clearDepth = function () { | |
| this.clear( false, true, false ); | |
| }; | |
| this.clearStencil = function () { | |
| this.clear( false, false, true ); | |
| }; | |
| this.clearTarget = function ( renderTarget, color, depth, stencil ) { | |
| this.setRenderTarget( renderTarget ); | |
| this.clear( color, depth, stencil ); | |
| }; | |
| // Reset | |
| this.resetGLState = resetGLState; | |
| this.dispose = function() { | |
| _canvas.removeEventListener( 'webglcontextlost', onContextLost, false ); | |
| }; | |
| // Events | |
| function onContextLost( event ) { | |
| event.preventDefault(); | |
| resetGLState(); | |
| setDefaultGLState(); | |
| properties.clear(); | |
| } | |
| function onTextureDispose( event ) { | |
| var texture = event.target; | |
| texture.removeEventListener( 'dispose', onTextureDispose ); | |
| deallocateTexture( texture ); | |
| _infoMemory.textures --; | |
| } | |
| function onRenderTargetDispose( event ) { | |
| var renderTarget = event.target; | |
| renderTarget.removeEventListener( 'dispose', onRenderTargetDispose ); | |
| deallocateRenderTarget( renderTarget ); | |
| _infoMemory.textures --; | |
| } | |
| function onMaterialDispose( event ) { | |
| var material = event.target; | |
| material.removeEventListener( 'dispose', onMaterialDispose ); | |
| deallocateMaterial( material ); | |
| } | |
| // Buffer deallocation | |
| function deallocateTexture( texture ) { | |
| var textureProperties = properties.get( texture ); | |
| if ( texture.image && textureProperties.__image__webglTextureCube ) { | |
| // cube texture | |
| _gl.deleteTexture( textureProperties.__image__webglTextureCube ); | |
| } else { | |
| // 2D texture | |
| if ( textureProperties.__webglInit === undefined ) return; | |
| _gl.deleteTexture( textureProperties.__webglTexture ); | |
| } | |
| // remove all webgl properties | |
| properties.delete( texture ); | |
| } | |
| function deallocateRenderTarget( renderTarget ) { | |
| var renderTargetProperties = properties.get( renderTarget ); | |
| var textureProperties = properties.get( renderTarget.texture ); | |
| if ( ! renderTarget || textureProperties.__webglTexture === undefined ) return; | |
| _gl.deleteTexture( textureProperties.__webglTexture ); | |
| if ( renderTarget instanceof THREE.WebGLRenderTargetCube ) { | |
| for ( var i = 0; i < 6; i ++ ) { | |
| _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] ); | |
| _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] ); | |
| } | |
| } else { | |
| _gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer ); | |
| _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer ); | |
| } | |
| properties.delete( renderTarget.texture ); | |
| properties.delete( renderTarget ); | |
| } | |
| function deallocateMaterial( material ) { | |
| releaseMaterialProgramReference( material ); | |
| properties.delete( material ); | |
| } | |
| function releaseMaterialProgramReference( material ) { | |
| var programInfo = properties.get( material ).program; | |
| material.program = undefined; | |
| if ( programInfo !== undefined ) { | |
| programCache.releaseProgram( programInfo ); | |
| } | |
| } | |
| // Buffer rendering | |
| this.renderBufferImmediate = function ( object, program, material ) { | |
| state.initAttributes(); | |
| var buffers = properties.get( object ); | |
| if ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer(); | |
| if ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer(); | |
| if ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer(); | |
| if ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer(); | |
| var attributes = program.getAttributes(); | |
| if ( object.hasPositions ) { | |
| _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.position ); | |
| _gl.bufferData( _gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW ); | |
| state.enableAttribute( attributes.position ); | |
| _gl.vertexAttribPointer( attributes.position, 3, _gl.FLOAT, false, 0, 0 ); | |
| } | |
| if ( object.hasNormals ) { | |
| _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal ); | |
| if ( material.type !== 'MeshPhongMaterial' && material.type !== 'MeshStandardMaterial' && material.shading === THREE.FlatShading ) { | |
| for ( var i = 0, l = object.count * 3; i < l; i += 9 ) { | |
| var array = object.normalArray; | |
| var nx = ( array[ i + 0 ] + array[ i + 3 ] + array[ i + 6 ] ) / 3; | |
| var ny = ( array[ i + 1 ] + array[ i + 4 ] + array[ i + 7 ] ) / 3; | |
| var nz = ( array[ i + 2 ] + array[ i + 5 ] + array[ i + 8 ] ) / 3; | |
| array[ i + 0 ] = nx; | |
| array[ i + 1 ] = ny; | |
| array[ i + 2 ] = nz; | |
| array[ i + 3 ] = nx; | |
| array[ i + 4 ] = ny; | |
| array[ i + 5 ] = nz; | |
| array[ i + 6 ] = nx; | |
| array[ i + 7 ] = ny; | |
| array[ i + 8 ] = nz; | |
| } | |
| } | |
| _gl.bufferData( _gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW ); | |
| state.enableAttribute( attributes.normal ); | |
| _gl.vertexAttribPointer( attributes.normal, 3, _gl.FLOAT, false, 0, 0 ); | |
| } | |
| if ( object.hasUvs && material.map ) { | |
| _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.uv ); | |
| _gl.bufferData( _gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW ); | |
| state.enableAttribute( attributes.uv ); | |
| _gl.vertexAttribPointer( attributes.uv, 2, _gl.FLOAT, false, 0, 0 ); | |
| } | |
| if ( object.hasColors && material.vertexColors !== THREE.NoColors ) { | |
| _gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.color ); | |
| _gl.bufferData( _gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW ); | |
| state.enableAttribute( attributes.color ); | |
| _gl.vertexAttribPointer( attributes.color, 3, _gl.FLOAT, false, 0, 0 ); | |
| } | |
| state.disableUnusedAttributes(); | |
| _gl.drawArrays( _gl.TRIANGLES, 0, object.count ); | |
| object.count = 0; | |
| }; | |
| this.renderBufferDirect = function ( camera, fog, geometry, material, object, group ) { | |
| setMaterial( material ); | |
| var program = setProgram( camera, fog, material, object ); | |
| var updateBuffers = false; | |
| var geometryProgram = geometry.id + '_' + program.id + '_' + material.wireframe; | |
| if ( geometryProgram !== _currentGeometryProgram ) { | |
| _currentGeometryProgram = geometryProgram; | |
| updateBuffers = true; | |
| } | |
| // morph targets | |
| var morphTargetInfluences = object.morphTargetInfluences; | |
| if ( morphTargetInfluences !== undefined ) { | |
| var activeInfluences = []; | |
| for ( var i = 0, l = morphTargetInfluences.length; i < l; i ++ ) { | |
| var influence = morphTargetInfluences[ i ]; | |
| activeInfluences.push( [ influence, i ] ); | |
| } | |
| activeInfluences.sort( absNumericalSort ); | |
| if ( activeInfluences.length > 8 ) { | |
| activeInfluences.length = 8; | |
| } | |
| var morphAttributes = geometry.morphAttributes; | |
| for ( var i = 0, l = activeInfluences.length; i < l; i ++ ) { | |
| var influence = activeInfluences[ i ]; | |
| morphInfluences[ i ] = influence[ 0 ]; | |
| if ( influence[ 0 ] !== 0 ) { | |
| var index = influence[ 1 ]; | |
| if ( material.morphTargets === true && morphAttributes.position ) geometry.addAttribute( 'morphTarget' + i, morphAttributes.position[ index ] ); | |
| if ( material.morphNormals === true && morphAttributes.normal ) geometry.addAttribute( 'morphNormal' + i, morphAttributes.normal[ index ] ); | |
| } else { | |
| if ( material.morphTargets === true ) geometry.removeAttribute( 'morphTarget' + i ); | |
| if ( material.morphNormals === true ) geometry.removeAttribute( 'morphNormal' + i ); | |
| } | |
| } | |
| var uniforms = program.getUniforms(); | |
| if ( uniforms.morphTargetInfluences !== null ) { | |
| _gl.uniform1fv( uniforms.morphTargetInfluences, morphInfluences ); | |
| } | |
| updateBuffers = true; | |
| } | |
| // | |
| var index = geometry.index; | |
| var position = geometry.attributes.position; | |
| if ( material.wireframe === true ) { | |
| index = objects.getWireframeAttribute( geometry ); | |
| } | |
| var renderer; | |
| if ( index !== null ) { | |
| renderer = indexedBufferRenderer; | |
| renderer.setIndex( index ); | |
| } else { | |
| renderer = bufferRenderer; | |
| } | |
| if ( updateBuffers ) { | |
| setupVertexAttributes( material, program, geometry ); | |
| if ( index !== null ) { | |
| _gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, objects.getAttributeBuffer( index ) ); | |
| } | |
| } | |
| // | |
| var dataStart = 0; | |
| var dataCount = Infinity; | |
| if ( index !== null ) { | |
| dataCount = index.count; | |
| } else if ( position !== undefined ) { | |
| dataCount = position.count; | |
| } | |
| var rangeStart = geometry.drawRange.start; | |
| var rangeCount = geometry.drawRange.count; | |
| var groupStart = group !== null ? group.start : 0; | |
| var groupCount = group !== null ? group.count : Infinity; | |
| var drawStart = Math.max( dataStart, rangeStart, groupStart ); | |
| var drawEnd = Math.min( dataStart + dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1; | |
| var drawCount = Math.max( 0, drawEnd - drawStart + 1 ); | |
| // | |
| if ( object instanceof THREE.Mesh ) { | |
| if ( material.wireframe === true ) { | |
| state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() ); | |
| renderer.setMode( _gl.LINES ); | |
| } else { | |
| switch ( object.drawMode ) { | |
| case THREE.TrianglesDrawMode: | |
| renderer.setMode( _gl.TRIANGLES ); | |
| break; | |
| case THREE.TriangleStripDrawMode: | |
| renderer.setMode( _gl.TRIANGLE_STRIP ); | |
| break; | |
| case THREE.TriangleFanDrawMode: | |
| renderer.setMode( _gl.TRIANGLE_FAN ); | |
| break; | |
| } | |
| } | |
| } else if ( object instanceof THREE.Line ) { | |
| var lineWidth = material.linewidth; | |
| if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material | |
| state.setLineWidth( lineWidth * getTargetPixelRatio() ); | |
| if ( object instanceof THREE.LineSegments ) { | |
| renderer.setMode( _gl.LINES ); | |
| } else { | |
| renderer.setMode( _gl.LINE_STRIP ); | |
| } | |
| } else if ( object instanceof THREE.Points ) { | |
| renderer.setMode( _gl.POINTS ); | |
| } | |
| if ( geometry instanceof THREE.InstancedBufferGeometry && geometry.maxInstancedCount > 0 ) { | |
| renderer.renderInstances( geometry, drawStart, drawCount ); | |
| } else { | |
| renderer.render( drawStart, drawCount ); | |
| } | |
| }; | |
| function setupVertexAttributes( material, program, geometry, startIndex ) { | |
| var extension; | |
| if ( geometry instanceof THREE.InstancedBufferGeometry ) { | |
| extension = extensions.get( 'ANGLE_instanced_arrays' ); | |
| if ( extension === null ) { | |
| console.error( 'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' ); | |
| return; | |
| } | |
| } | |
| if ( startIndex === undefined ) startIndex = 0; | |
| state.initAttributes(); | |
| var geometryAttributes = geometry.attributes; | |
| var programAttributes = program.getAttributes(); | |
| var materialDefaultAttributeValues = material.defaultAttributeValues; | |
| for ( var name in programAttributes ) { | |
| var programAttribute = programAttributes[ name ]; | |
| if ( programAttribute >= 0 ) { | |
| var geometryAttribute = geometryAttributes[ name ]; | |
| if ( geometryAttribute !== undefined ) { | |
| var size = geometryAttribute.itemSize; | |
| var buffer = objects.getAttributeBuffer( geometryAttribute ); | |
| if ( geometryAttribute instanceof THREE.InterleavedBufferAttribute ) { | |
| var data = geometryAttribute.data; | |
| var stride = data.stride; | |
| var offset = geometryAttribute.offset; | |
| if ( data instanceof THREE.InstancedInterleavedBuffer ) { | |
| state.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute, extension ); | |
| if ( geometry.maxInstancedCount === undefined ) { | |
| geometry.maxInstancedCount = data.meshPerAttribute * data.count; | |
| } | |
| } else { | |
| state.enableAttribute( programAttribute ); | |
| } | |
| _gl.bindBuffer( _gl.ARRAY_BUFFER, buffer ); | |
| _gl.vertexAttribPointer( programAttribute, size, _gl.FLOAT, false, stride * data.array.BYTES_PER_ELEMENT, ( startIndex * stride + offset ) * data.array.BYTES_PER_ELEMENT ); | |
| } else { | |
| if ( geometryAttribute instanceof THREE.InstancedBufferAttribute ) { | |
| state.enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute, extension ); | |
| if ( geometry.maxInstancedCount === undefined ) { | |
| geometry.maxInstancedCount = geometryAttribute.meshPerAttribute * geometryAttribute.count; | |
| } | |
| } else { | |
| state.enableAttribute( programAttribute ); | |
| } | |
| _gl.bindBuffer( _gl.ARRAY_BUFFER, buffer ); | |
| _gl.vertexAttribPointer( programAttribute, size, _gl.FLOAT, false, 0, startIndex * size * 4 ); // 4 bytes per Float32 | |
| } | |
| } else if ( materialDefaultAttributeValues !== undefined ) { | |
| var value = materialDefaultAttributeValues[ name ]; | |
| if ( value !== undefined ) { | |
| switch ( value.length ) { | |
| case 2: | |
| _gl.vertexAttrib2fv( programAttribute, value ); | |
| break; | |
| case 3: | |
| _gl.vertexAttrib3fv( programAttribute, value ); | |
| break; | |
| case 4: | |
| _gl.vertexAttrib4fv( programAttribute, value ); | |
| break; | |
| default: | |
| _gl.vertexAttrib1fv( programAttribute, value ); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| state.disableUnusedAttributes(); | |
| } | |
| // Sorting | |
| function absNumericalSort( a, b ) { | |
| return Math.abs( b[ 0 ] ) - Math.abs( a[ 0 ] ); | |
| } | |
| function painterSortStable ( a, b ) { | |
| if ( a.object.renderOrder !== b.object.renderOrder ) { | |
| return a.object.renderOrder - b.object.renderOrder; | |
| } else if ( a.material.id !== b.material.id ) { | |
| return a.material.id - b.material.id; | |
| } else if ( a.z !== b.z ) { | |
| return a.z - b.z; | |
| } else { | |
| return a.id - b.id; | |
| } | |
| } | |
| function reversePainterSortStable ( a, b ) { | |
| if ( a.object.renderOrder !== b.object.renderOrder ) { | |
| return a.object.renderOrder - b.object.renderOrder; | |
| } if ( a.z !== b.z ) { | |
| return b.z - a.z; | |
| } else { | |
| return a.id - b.id; | |
| } | |
| } | |
| // Rendering | |
| this.render = function ( scene, camera, renderTarget, forceClear ) { | |
| if ( camera instanceof THREE.Camera === false ) { | |
| console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' ); | |
| return; | |
| } | |
| var fog = scene.fog; | |
| // reset caching for this frame | |
| _currentGeometryProgram = ''; | |
| _currentMaterialId = - 1; | |
| _currentCamera = null; | |
| // update scene graph | |
| if ( scene.autoUpdate === true ) scene.updateMatrixWorld(); | |
| // update camera matrices and frustum | |
| if ( camera.parent === null ) camera.updateMatrixWorld(); | |
| camera.matrixWorldInverse.getInverse( camera.matrixWorld ); | |
| _projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse ); | |
| _frustum.setFromMatrix( _projScreenMatrix ); | |
| lights.length = 0; | |
| opaqueObjectsLastIndex = - 1; | |
| transparentObjectsLastIndex = - 1; | |
| sprites.length = 0; | |
| lensFlares.length = 0; | |
| projectObject( scene, camera ); | |
| opaqueObjects.length = opaqueObjectsLastIndex + 1; | |
| transparentObjects.length = transparentObjectsLastIndex + 1; | |
| if ( _this.sortObjects === true ) { | |
| opaqueObjects.sort( painterSortStable ); | |
| transparentObjects.sort( reversePainterSortStable ); | |
| } | |
| setupLights( lights, camera ); | |
| // | |
| shadowMap.render( scene, camera ); | |
| // | |
| _infoRender.calls = 0; | |
| _infoRender.vertices = 0; | |
| _infoRender.faces = 0; | |
| _infoRender.points = 0; | |
| if ( renderTarget === undefined ) { | |
| renderTarget = null; | |
| } | |
| this.setRenderTarget( renderTarget ); | |
| if ( this.autoClear || forceClear ) { | |
| this.clear( this.autoClearColor, this.autoClearDepth, this.autoClearStencil ); | |
| } | |
| // | |
| if ( scene.overrideMaterial ) { | |
| var overrideMaterial = scene.overrideMaterial; | |
| renderObjects( opaqueObjects, camera, fog, overrideMaterial ); | |
| renderObjects( transparentObjects, camera, fog, overrideMaterial ); | |
| } else { | |
| // opaque pass (front-to-back order) | |
| state.setBlending( THREE.NoBlending ); | |
| renderObjects( opaqueObjects, camera, fog ); | |
| // transparent pass (back-to-front order) | |
| renderObjects( transparentObjects, camera, fog ); | |
| } | |
| // custom render plugins (post pass) | |
| spritePlugin.render( scene, camera ); | |
| lensFlarePlugin.render( scene, camera, _currentViewport ); | |
| // Generate mipmap if we're using any kind of mipmap filtering | |
| if ( renderTarget ) { | |
| var texture = renderTarget.texture; | |
| if ( texture.generateMipmaps && isPowerOfTwo( renderTarget ) && | |
| texture.minFilter !== THREE.NearestFilter && | |
| texture.minFilter !== THREE.LinearFilter ) { | |
| updateRenderTargetMipmap( renderTarget ); | |
| } | |
| } | |
| // Ensure depth buffer writing is enabled so it can be cleared on next render | |
| state.setDepthTest( true ); | |
| state.setDepthWrite( true ); | |
| state.setColorWrite( true ); | |
| // _gl.finish(); | |
| }; | |
| function pushRenderItem( object, geometry, material, z, group ) { | |
| var array, index; | |
| // allocate the next position in the appropriate array | |
| if ( material.transparent ) { | |
| array = transparentObjects; | |
| index = ++ transparentObjectsLastIndex; | |
| } else { | |
| array = opaqueObjects; | |
| index = ++ opaqueObjectsLastIndex; | |
| } | |
| // recycle existing render item or grow the array | |
| var renderItem = array[ index ]; | |
| if ( renderItem !== undefined ) { | |
| renderItem.id = object.id; | |
| renderItem.object = object; | |
| renderItem.geometry = geometry; | |
| renderItem.material = material; | |
| renderItem.z = _vector3.z; | |
| renderItem.group = group; | |
| } else { | |
| renderItem = { | |
| id: object.id, | |
| object: object, | |
| geometry: geometry, | |
| material: material, | |
| z: _vector3.z, | |
| group: group | |
| }; | |
| // assert( index === array.length ); | |
| array.push( renderItem ); | |
| } | |
| } | |
| function projectObject( object, camera ) { | |
| if ( object.visible === false ) return; | |
| if ( object.layers.test( camera.layers ) ) { | |
| if ( object instanceof THREE.Light ) { | |
| lights.push( object ); | |
| } else if ( object instanceof THREE.Sprite ) { | |
| if ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) { | |
| sprites.push( object ); | |
| } | |
| } else if ( object instanceof THREE.LensFlare ) { | |
| lensFlares.push( object ); | |
| } else if ( object instanceof THREE.ImmediateRenderObject ) { | |
| if ( _this.sortObjects === true ) { | |
| _vector3.setFromMatrixPosition( object.matrixWorld ); | |
| _vector3.applyProjection( _projScreenMatrix ); | |
| } | |
| pushRenderItem( object, null, object.material, _vector3.z, null ); | |
| } else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points ) { | |
| if ( object instanceof THREE.SkinnedMesh ) { | |
| object.skeleton.update(); | |
| } | |
| if ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) { | |
| var material = object.material; | |
| if ( material.visible === true ) { | |
| if ( _this.sortObjects === true ) { | |
| _vector3.setFromMatrixPosition( object.matrixWorld ); | |
| _vector3.applyProjection( _projScreenMatrix ); | |
| } | |
| var geometry = objects.update( object ); | |
| if ( material instanceof THREE.MultiMaterial ) { | |
| var groups = geometry.groups; | |
| var materials = material.materials; | |
| for ( var i = 0, l = groups.length; i < l; i ++ ) { | |
| var group = groups[ i ]; | |
| var groupMaterial = materials[ group.materialIndex ]; | |
| if ( groupMaterial.visible === true ) { | |
| pushRenderItem( object, geometry, groupMaterial, _vector3.z, group ); | |
| } | |
| } | |
| } else { | |
| pushRenderItem( object, geometry, material, _vector3.z, null ); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| var children = object.children; | |
| for ( var i = 0, l = children.length; i < l; i ++ ) { | |
| projectObject( children[ i ], camera ); | |
| } | |
| } | |
| function renderObjects( renderList, camera, fog, overrideMaterial ) { | |
| for ( var i = 0, l = renderList.length; i < l; i ++ ) { | |
| var renderItem = renderList[ i ]; | |
| var object = renderItem.object; | |
| var geometry = renderItem.geometry; | |
| var material = overrideMaterial === undefined ? renderItem.material : overrideMaterial; | |
| var group = renderItem.group; | |
| object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld ); | |
| object.normalMatrix.getNormalMatrix( object.modelViewMatrix ); | |
| if ( object instanceof THREE.ImmediateRenderObject ) { | |
| setMaterial( material ); | |
| var program = setProgram( camera, fog, material, object ); | |
| _currentGeometryProgram = ''; | |
| object.render( function ( object ) { | |
| _this.renderBufferImmediate( object, program, material ); | |
| } ); | |
| } else { | |
| _this.renderBufferDirect( camera, fog, geometry, material, object, group ); | |
| } | |
| } | |
| } | |
| function initMaterial( material, fog, object ) { | |
| var materialProperties = properties.get( material ); | |
| var parameters = programCache.getParameters( material, _lights, fog, object ); | |
| var code = programCache.getProgramCode( material, parameters ); | |
| var program = materialProperties.program; | |
| var programChange = true; | |
| if ( program === undefined ) { | |
| // new material | |
| material.addEventListener( 'dispose', onMaterialDispose ); | |
| } else if ( program.code !== code ) { | |
| // changed glsl or parameters | |
| releaseMaterialProgramReference( material ); | |
| } else if ( parameters.shaderID !== undefined ) { | |
| // same glsl and uniform list | |
| return; | |
| } else { | |
| // only rebuild uniform list | |
| programChange = false; | |
| } | |
| if ( programChange ) { | |
| if ( parameters.shaderID ) { | |
| var shader = THREE.ShaderLib[ parameters.shaderID ]; | |
| materialProperties.__webglShader = { | |
| name: material.type, | |
| uniforms: THREE.UniformsUtils.clone( shader.uniforms ), | |
| vertexShader: shader.vertexShader, | |
| fragmentShader: shader.fragmentShader | |
| }; | |
| } else { | |
| materialProperties.__webglShader = { | |
| name: material.type, | |
| uniforms: material.uniforms, | |
| vertexShader: material.vertexShader, | |
| fragmentShader: material.fragmentShader | |
| }; | |
| } | |
| material.__webglShader = materialProperties.__webglShader; | |
| program = programCache.acquireProgram( material, parameters, code ); | |
| materialProperties.program = program; | |
| material.program = program; | |
| } | |
| var attributes = program.getAttributes(); | |
| if ( material.morphTargets ) { | |
| material.numSupportedMorphTargets = 0; | |
| for ( var i = 0; i < _this.maxMorphTargets; i ++ ) { | |
| if ( attributes[ 'morphTarget' + i ] >= 0 ) { | |
| material.numSupportedMorphTargets ++; | |
| } | |
| } | |
| } | |
| if ( material.morphNormals ) { | |
| material.numSupportedMorphNormals = 0; | |
| for ( var i = 0; i < _this.maxMorphNormals; i ++ ) { | |
| if ( attributes[ 'morphNormal' + i ] >= 0 ) { | |
| material.numSupportedMorphNormals ++; | |
| } | |
| } | |
| } | |
| materialProperties.uniformsList = []; | |
| var uniforms = materialProperties.__webglShader.uniforms, | |
| uniformLocations = materialProperties.program.getUniforms(); | |
| for ( var u in uniforms ) { | |
| var location = uniformLocations[ u ]; | |
| if ( location ) { | |
| materialProperties.uniformsList.push( [ materialProperties.__webglShader.uniforms[ u ], location ] ); | |
| } | |
| } | |
| if ( material instanceof THREE.MeshPhongMaterial || | |
| material instanceof THREE.MeshLambertMaterial || | |
| material instanceof THREE.MeshStandardMaterial || | |
| material.lights ) { | |
| // store the light setup it was created for | |
| materialProperties.lightsHash = _lights.hash; | |
| // wire up the material to this renderer's lighting state | |
| uniforms.ambientLightColor.value = _lights.ambient; | |
| uniforms.directionalLights.value = _lights.directional; | |
| uniforms.spotLights.value = _lights.spot; | |
| uniforms.pointLights.value = _lights.point; | |
| uniforms.hemisphereLights.value = _lights.hemi; | |
| uniforms.directionalShadowMap.value = _lights.directionalShadowMap; | |
| uniforms.directionalShadowMatrix.value = _lights.directionalShadowMatrix; | |
| uniforms.spotShadowMap.value = _lights.spotShadowMap; | |
| uniforms.spotShadowMatrix.value = _lights.spotShadowMatrix; | |
| uniforms.pointShadowMap.value = _lights.pointShadowMap; | |
| uniforms.pointShadowMatrix.value = _lights.pointShadowMatrix; | |
| } | |
| // detect dynamic uniforms | |
| materialProperties.hasDynamicUniforms = false; | |
| for ( var j = 0, jl = materialProperties.uniformsList.length; j < jl; j ++ ) { | |
| var uniform = materialProperties.uniformsList[ j ][ 0 ]; | |
| if ( uniform.dynamic === true ) { | |
| materialProperties.hasDynamicUniforms = true; | |
| break; | |
| } | |
| } | |
| } | |
| function setMaterial( material ) { | |
| setMaterialFaces( material ); | |
| if ( material.transparent === true ) { | |
| state.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha ); | |
| } else { | |
| state.setBlending( THREE.NoBlending ); | |
| } | |
| state.setDepthFunc( material.depthFunc ); | |
| state.setDepthTest( material.depthTest ); | |
| state.setDepthWrite( material.depthWrite ); | |
| state.setColorWrite( material.colorWrite ); | |
| state.setPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits ); | |
| } | |
| function setMaterialFaces( material ) { | |
| material.side !== THREE.DoubleSide ? state.enable( _gl.CULL_FACE ) : state.disable( _gl.CULL_FACE ); | |
| state.setFlipSided( material.side === THREE.BackSide ); | |
| } | |
| function setProgram( camera, fog, material, object ) { | |
| _usedTextureUnits = 0; | |
| var materialProperties = properties.get( material ); | |
| if ( materialProperties.program === undefined ) { | |
| material.needsUpdate = true; | |
| } | |
| if ( materialProperties.lightsHash !== undefined && | |
| materialProperties.lightsHash !== _lights.hash ) { | |
| material.needsUpdate = true; | |
| } | |
| if ( material.needsUpdate ) { | |
| initMaterial( material, fog, object ); | |
| material.needsUpdate = false; | |
| } | |
| var refreshProgram = false; | |
| var refreshMaterial = false; | |
| var refreshLights = false; | |
| var program = materialProperties.program, | |
| p_uniforms = program.getUniforms(), | |
| m_uniforms = materialProperties.__webglShader.uniforms; | |
| if ( program.id !== _currentProgram ) { | |
| _gl.useProgram( program.program ); | |
| _currentProgram = program.id; | |
| refreshProgram = true; | |
| refreshMaterial = true; | |
| refreshLights = true; | |
| } | |
| if ( material.id !== _currentMaterialId ) { | |
| _currentMaterialId = material.id; | |
| refreshMaterial = true; | |
| } | |
| if ( refreshProgram || camera !== _currentCamera ) { | |
| _gl.uniformMatrix4fv( p_uniforms.projectionMatrix, false, camera.projectionMatrix.elements ); | |
| if ( capabilities.logarithmicDepthBuffer ) { | |
| _gl.uniform1f( p_uniforms.logDepthBufFC, 2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) ); | |
| } | |
| if ( camera !== _currentCamera ) { | |
| _currentCamera = camera; | |
| // lighting uniforms depend on the camera so enforce an update | |
| // now, in case this material supports lights - or later, when | |
| // the next material that does gets activated: | |
| refreshMaterial = true; // set to true on material change | |
| refreshLights = true; // remains set until update done | |
| } | |
| // load material specific uniforms | |
| // (shader material also gets them for the sake of genericity) | |
| if ( material instanceof THREE.ShaderMaterial || | |
| material instanceof THREE.MeshPhongMaterial || | |
| material instanceof THREE.MeshStandardMaterial || | |
| material.envMap ) { | |
| if ( p_uniforms.cameraPosition !== undefined ) { | |
| _vector3.setFromMatrixPosition( camera.matrixWorld ); | |
| _gl.uniform3f( p_uniforms.cameraPosition, _vector3.x, _vector3.y, _vector3.z ); | |
| } | |
| } | |
| if ( material instanceof THREE.MeshPhongMaterial || | |
| material instanceof THREE.MeshLambertMaterial || | |
| material instanceof THREE.MeshBasicMaterial || | |
| material instanceof THREE.MeshStandardMaterial || | |
| material instanceof THREE.ShaderMaterial || | |
| material.skinning ) { | |
| if ( p_uniforms.viewMatrix !== undefined ) { | |
| _gl.uniformMatrix4fv( p_uniforms.viewMatrix, false, camera.matrixWorldInverse.elements ); | |
| } | |
| } | |
| } | |
| // skinning uniforms must be set even if material didn't change | |
| // auto-setting of texture unit for bone texture must go before other textures | |
| // not sure why, but otherwise weird things happen | |
| if ( material.skinning ) { | |
| if ( object.bindMatrix && p_uniforms.bindMatrix !== undefined ) { | |
| _gl.uniformMatrix4fv( p_uniforms.bindMatrix, false, object.bindMatrix.elements ); | |
| } | |
| if ( object.bindMatrixInverse && p_uniforms.bindMatrixInverse !== undefined ) { | |
| _gl.uniformMatrix4fv( p_uniforms.bindMatrixInverse, false, object.bindMatrixInverse.elements ); | |
| } | |
| if ( capabilities.floatVertexTextures && object.skeleton && object.skeleton.useVertexTexture ) { | |
| if ( p_uniforms.boneTexture !== undefined ) { | |
| var textureUnit = getTextureUnit(); | |
| _gl.uniform1i( p_uniforms.boneTexture, textureUnit ); | |
| _this.setTexture( object.skeleton.boneTexture, textureUnit ); | |
| } | |
| if ( p_uniforms.boneTextureWidth !== undefined ) { | |
| _gl.uniform1i( p_uniforms.boneTextureWidth, object.skeleton.boneTextureWidth ); | |
| } | |
| if ( p_uniforms.boneTextureHeight !== undefined ) { | |
| _gl.uniform1i( p_uniforms.boneTextureHeight, object.skeleton.boneTextureHeight ); | |
| } | |
| } else if ( object.skeleton && object.skeleton.boneMatrices ) { | |
| if ( p_uniforms.boneGlobalMatrices !== undefined ) { | |
| _gl.uniformMatrix4fv( p_uniforms.boneGlobalMatrices, false, object.skeleton.boneMatrices ); | |
| } | |
| } | |
| } | |
| if ( refreshMaterial ) { | |
| if ( material instanceof THREE.MeshPhongMaterial || | |
| material instanceof THREE.MeshLambertMaterial || | |
| material instanceof THREE.MeshStandardMaterial || | |
| material.lights ) { | |
| // the current material requires lighting info | |
| // note: all lighting uniforms are always set correctly | |
| // they simply reference the renderer's state for their | |
| // values | |
| // | |
| // use the current material's .needsUpdate flags to set | |
| // the GL state when required | |
| markUniformsLightsNeedsUpdate( m_uniforms, refreshLights ); | |
| } | |
| // refresh uniforms common to several materials | |
| if ( fog && material.fog ) { | |
| refreshUniformsFog( m_uniforms, fog ); | |
| } | |
| if ( material instanceof THREE.MeshBasicMaterial || | |
| material instanceof THREE.MeshLambertMaterial || | |
| material instanceof THREE.MeshPhongMaterial || | |
| material instanceof THREE.MeshStandardMaterial ) { | |
| refreshUniformsCommon( m_uniforms, material ); | |
| } | |
| // refresh single material specific uniforms | |
| if ( material instanceof THREE.LineBasicMaterial ) { | |
| refreshUniformsLine( m_uniforms, material ); | |
| } else if ( material instanceof THREE.LineDashedMaterial ) { | |
| refreshUniformsLine( m_uniforms, material ); | |
| refreshUniformsDash( m_uniforms, material ); | |
| } else if ( material instanceof THREE.PointsMaterial ) { | |
| refreshUniformsPoints( m_uniforms, material ); | |
| } else if ( material instanceof THREE.MeshLambertMaterial ) { | |
| refreshUniformsLambert( m_uniforms, material ); | |
| } else if ( material instanceof THREE.MeshPhongMaterial ) { | |
| refreshUniformsPhong( m_uniforms, material ); | |
| } else if ( material instanceof THREE.MeshStandardMaterial ) { | |
| refreshUniformsStandard( m_uniforms, material ); | |
| } else if ( material instanceof THREE.MeshDepthMaterial ) { | |
| m_uniforms.mNear.value = camera.near; | |
| m_uniforms.mFar.value = camera.far; | |
| m_uniforms.opacity.value = material.opacity; | |
| } else if ( material instanceof THREE.MeshNormalMaterial ) { | |
| m_uniforms.opacity.value = material.opacity; | |
| } | |
| // load common uniforms | |
| loadUniformsGeneric( materialProperties.uniformsList ); | |
| } | |
| loadUniformsMatrices( p_uniforms, object ); | |
| if ( p_uniforms.modelMatrix !== undefined ) { | |
| _gl.uniformMatrix4fv( p_uniforms.modelMatrix, false, object.matrixWorld.elements ); | |
| } | |
| if ( materialProperties.hasDynamicUniforms === true ) { | |
| updateDynamicUniforms( materialProperties.uniformsList, object, camera ); | |
| } | |
| return program; | |
| } | |
| function updateDynamicUniforms ( uniforms, object, camera ) { | |
| var dynamicUniforms = []; | |
| for ( var j = 0, jl = uniforms.length; j < jl; j ++ ) { | |
| var uniform = uniforms[ j ][ 0 ]; | |
| var onUpdateCallback = uniform.onUpdateCallback; | |
| if ( onUpdateCallback !== undefined ) { | |
| onUpdateCallback.bind( uniform )( object, camera ); | |
| dynamicUniforms.push( uniforms[ j ] ); | |
| } | |
| } | |
| loadUniformsGeneric( dynamicUniforms ); | |
| } | |
| // Uniforms (refresh uniforms objects) | |
| function refreshUniformsCommon ( uniforms, material ) { | |
| uniforms.opacity.value = material.opacity; | |
| uniforms.diffuse.value = material.color; | |
| if ( material.emissive ) { | |
| uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity ); | |
| } | |
| uniforms.map.value = material.map; | |
| uniforms.specularMap.value = material.specularMap; | |
| uniforms.alphaMap.value = material.alphaMap; | |
| if ( material.aoMap ) { | |
| uniforms.aoMap.value = material.aoMap; | |
| uniforms.aoMapIntensity.value = material.aoMapIntensity; | |
| } | |
| // uv repeat and offset setting priorities | |
| // 1. color map | |
| // 2. specular map | |
| // 3. normal map | |
| // 4. bump map | |
| // 5. alpha map | |
| // 6. emissive map | |
| var uvScaleMap; | |
| if ( material.map ) { | |
| uvScaleMap = material.map; | |
| } else if ( material.specularMap ) { | |
| uvScaleMap = material.specularMap; | |
| } else if ( material.displacementMap ) { | |
| uvScaleMap = material.displacementMap; | |
| } else if ( material.normalMap ) { | |
| uvScaleMap = material.normalMap; | |
| } else if ( material.bumpMap ) { | |
| uvScaleMap = material.bumpMap; | |
| } else if ( material.roughnessMap ) { | |
| uvScaleMap = material.roughnessMap; | |
| } else if ( material.metalnessMap ) { | |
| uvScaleMap = material.metalnessMap; | |
| } else if ( material.alphaMap ) { | |
| uvScaleMap = material.alphaMap; | |
| } else if ( material.emissiveMap ) { | |
| uvScaleMap = material.emissiveMap; | |
| } | |
| if ( uvScaleMap !== undefined ) { | |
| if ( uvScaleMap instanceof THREE.WebGLRenderTarget ) { | |
| uvScaleMap = uvScaleMap.texture; | |
| } | |
| var offset = uvScaleMap.offset; | |
| var repeat = uvScaleMap.repeat; | |
| uniforms.offsetRepeat.value.set( offset.x, offset.y, repeat.x, repeat.y ); | |
| } | |
| uniforms.envMap.value = material.envMap; | |
| uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1; | |
| uniforms.reflectivity.value = material.reflectivity; | |
| uniforms.refractionRatio.value = material.refractionRatio; | |
| } | |
| function refreshUniformsLine ( uniforms, material ) { | |
| uniforms.diffuse.value = material.color; | |
| uniforms.opacity.value = material.opacity; | |
| } | |
| function refreshUniformsDash ( uniforms, material ) { | |
| uniforms.dashSize.value = material.dashSize; | |
| uniforms.totalSize.value = material.dashSize + material.gapSize; | |
| uniforms.scale.value = material.scale; | |
| } | |
| function refreshUniformsPoints ( uniforms, material ) { | |
| uniforms.diffuse.value = material.color; | |
| uniforms.opacity.value = material.opacity; | |
| uniforms.size.value = material.size * _pixelRatio; | |
| uniforms.scale.value = _canvas.clientHeight / 2.0; // TODO: Cache this. | |
| uniforms.map.value = material.map; | |
| if ( material.map !== null ) { | |
| var offset = material.map.offset; | |
| var repeat = material.map.repeat; | |
| uniforms.offsetRepeat.value.set( offset.x, offset.y, repeat.x, repeat.y ); | |
| } | |
| } | |
| function refreshUniformsFog ( uniforms, fog ) { | |
| uniforms.fogColor.value = fog.color; | |
| if ( fog instanceof THREE.Fog ) { | |
| uniforms.fogNear.value = fog.near; | |
| uniforms.fogFar.value = fog.far; | |
| } else if ( fog instanceof THREE.FogExp2 ) { | |
| uniforms.fogDensity.value = fog.density; | |
| } | |
| } | |
| function refreshUniformsLambert ( uniforms, material ) { | |
| if ( material.lightMap ) { | |
| uniforms.lightMap.value = material.lightMap; | |
| uniforms.lightMapIntensity.value = material.lightMapIntensity; | |
| } | |
| if ( material.emissiveMap ) { | |
| uniforms.emissiveMap.value = material.emissiveMap; | |
| } | |
| } | |
| function refreshUniformsPhong ( uniforms, material ) { | |
| uniforms.specular.value = material.specular; | |
| uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 ) | |
| if ( material.lightMap ) { | |
| uniforms.lightMap.value = material.lightMap; | |
| uniforms.lightMapIntensity.value = material.lightMapIntensity; | |
| } | |
| if ( material.emissiveMap ) { | |
| uniforms.emissiveMap.value = material.emissiveMap; | |
| } | |
| if ( material.bumpMap ) { | |
| uniforms.bumpMap.value = material.bumpMap; | |
| uniforms.bumpScale.value = material.bumpScale; | |
| } | |
| if ( material.normalMap ) { | |
| uniforms.normalMap.value = material.normalMap; | |
| uniforms.normalScale.value.copy( material.normalScale ); | |
| } | |
| if ( material.displacementMap ) { | |
| uniforms.displacementMap.value = material.displacementMap; | |
| uniforms.displacementScale.value = material.displacementScale; | |
| uniforms.displacementBias.value = material.displacementBias; | |
| } | |
| } | |
| function refreshUniformsStandard ( uniforms, material ) { | |
| uniforms.roughness.value = material.roughness; | |
| uniforms.metalness.value = material.metalness; | |
| if ( material.roughnessMap ) { | |
| uniforms.roughnessMap.value = material.roughnessMap; | |
| } | |
| if ( material.metalnessMap ) { | |
| uniforms.metalnessMap.value = material.metalnessMap; | |
| } | |
| if ( material.lightMap ) { | |
| uniforms.lightMap.value = material.lightMap; | |
| uniforms.lightMapIntensity.value = material.lightMapIntensity; | |
| } | |
| if ( material.emissiveMap ) { | |
| uniforms.emissiveMap.value = material.emissiveMap; | |
| } | |
| if ( material.bumpMap ) { | |
| uniforms.bumpMap.value = material.bumpMap; | |
| uniforms.bumpScale.value = material.bumpScale; | |
| } | |
| if ( material.normalMap ) { | |
| uniforms.normalMap.value = material.normalMap; | |
| uniforms.normalScale.value.copy( material.normalScale ); | |
| } | |
| if ( material.displacementMap ) { | |
| uniforms.displacementMap.value = material.displacementMap; | |
| uniforms.displacementScale.value = material.displacementScale; | |
| uniforms.displacementBias.value = material.displacementBias; | |
| } | |
| if ( material.envMap ) { | |
| //uniforms.envMap.value = material.envMap; // part of uniforms common | |
| uniforms.envMapIntensity.value = material.envMapIntensity; | |
| } | |
| } | |
| // If uniforms are marked as clean, they don't need to be loaded to the GPU. | |
| function markUniformsLightsNeedsUpdate ( uniforms, value ) { | |
| uniforms.ambientLightColor.needsUpdate = value; | |
| uniforms.directionalLights.needsUpdate = value; | |
| uniforms.pointLights.needsUpdate = value; | |
| uniforms.spotLights.needsUpdate = value; | |
| uniforms.hemisphereLights.needsUpdate = value; | |
| } | |
| // Uniforms (load to GPU) | |
| function loadUniformsMatrices ( uniforms, object ) { | |
| _gl.uniformMatrix4fv( uniforms.modelViewMatrix, false, object.modelViewMatrix.elements ); | |
| if ( uniforms.normalMatrix ) { | |
| _gl.uniformMatrix3fv( uniforms.normalMatrix, false, object.normalMatrix.elements ); | |
| } | |
| } | |
| function getTextureUnit() { | |
| var textureUnit = _usedTextureUnits; | |
| if ( textureUnit >= capabilities.maxTextures ) { | |
| console.warn( 'WebGLRenderer: trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures ); | |
| } | |
| _usedTextureUnits += 1; | |
| return textureUnit; | |
| } | |
| function loadUniformsGeneric ( uniforms ) { | |
| var texture, textureUnit; | |
| for ( var j = 0, jl = uniforms.length; j < jl; j ++ ) { | |
| var uniform = uniforms[ j ][ 0 ]; | |
| // needsUpdate property is not added to all uniforms. | |
| if ( uniform.needsUpdate === false ) continue; | |
| var type = uniform.type; | |
| var value = uniform.value; | |
| var location = uniforms[ j ][ 1 ]; | |
| switch ( type ) { | |
| case '1i': | |
| _gl.uniform1i( location, value ); | |
| break; | |
| case '1f': | |
| _gl.uniform1f( location, value ); | |
| break; | |
| case '2f': | |
| _gl.uniform2f( location, value[ 0 ], value[ 1 ] ); | |
| break; | |
| case '3f': | |
| _gl.uniform3f( location, value[ 0 ], value[ 1 ], value[ 2 ] ); | |
| break; | |
| case '4f': | |
| _gl.uniform4f( location, value[ 0 ], value[ 1 ], value[ 2 ], value[ 3 ] ); | |
| break; | |
| case '1iv': | |
| _gl.uniform1iv( location, value ); | |
| break; | |
| case '3iv': | |
| _gl.uniform3iv( location, value ); | |
| break; | |
| case '1fv': | |
| _gl.uniform1fv( location, value ); | |
| break; | |
| case '2fv': | |
| _gl.uniform2fv( location, value ); | |
| break; | |
| case '3fv': | |
| _gl.uniform3fv( location, value ); | |
| break; | |
| case '4fv': | |
| _gl.uniform4fv( location, value ); | |
| break; | |
| case 'Matrix2fv': | |
| _gl.uniformMatrix2fv( location, false, value ); | |
| break; | |
| case 'Matrix3fv': | |
| _gl.uniformMatrix3fv( location, false, value ); | |
| break; | |
| case 'Matrix4fv': | |
| _gl.uniformMatrix4fv( location, false, value ); | |
| break; | |
| // | |
| case 'i': | |
| // single integer | |
| _gl.uniform1i( location, value ); | |
| break; | |
| case 'f': | |
| // single float | |
| _gl.uniform1f( location, value ); | |
| break; | |
| case 'v2': | |
| // single THREE.Vector2 | |
| _gl.uniform2f( location, value.x, value.y ); | |
| break; | |
| case 'v3': | |
| // single THREE.Vector3 | |
| _gl.uniform3f( location, value.x, value.y, value.z ); | |
| break; | |
| case 'v4': | |
| // single THREE.Vector4 | |
| _gl.uniform4f( location, value.x, value.y, value.z, value.w ); | |
| break; | |
| case 'c': | |
| // single THREE.Color | |
| _gl.uniform3f( location, value.r, value.g, value.b ); | |
| break; | |
| /* | |
| case 's': | |
| // TODO: Optimize this. | |
| for( var propertyName in uniform.properties ) { | |
| var property = uniform.properties[ propertyName ]; | |
| var locationProperty = location[ propertyName ]; | |
| var valueProperty = value[ propertyName ]; | |
| switch( property.type ) { | |
| case 'i': | |
| _gl.uniform1i( locationProperty, valueProperty ); | |
| break; | |
| case 'f': | |
| _gl.uniform1f( locationProperty, valueProperty ); | |
| break; | |
| case 'v2': | |
| _gl.uniform2f( locationProperty, valueProperty.x, valueProperty.y ); | |
| break; | |
| case 'v3': | |
| _gl.uniform3f( locationProperty, valueProperty.x, valueProperty.y, valueProperty.z ); | |
| break; | |
| case 'v4': | |
| _gl.uniform4f( locationProperty, valueProperty.x, valueProperty.y, valueProperty.z, valueProperty.w ); | |
| break; | |
| case 'c': | |
| _gl.uniform3f( locationProperty, valueProperty.r, valueProperty.g, valueProperty.b ); | |
| break; | |
| }; | |
| } | |
| break; | |
| */ | |
| case 'sa': | |
| // TODO: Optimize this. | |
| for ( var i = 0; i < value.length; i ++ ) { | |
| for ( var propertyName in uniform.properties ) { | |
| var property = uniform.properties[ propertyName ]; | |
| var locationProperty = location[ i ][ propertyName ]; | |
| var valueProperty = value[ i ][ propertyName ]; | |
| switch ( property.type ) { | |
| case 'i': | |
| _gl.uniform1i( locationProperty, valueProperty ); | |
| break; | |
| case 'f': | |
| _gl.uniform1f( locationProperty, valueProperty ); | |
| break; | |
| case 'v2': | |
| _gl.uniform2f( locationProperty, valueProperty.x, valueProperty.y ); | |
| break; | |
| case 'v3': | |
| _gl.uniform3f( locationProperty, valueProperty.x, valueProperty.y, valueProperty.z ); | |
| break; | |
| case 'v4': | |
| _gl.uniform4f( locationProperty, valueProperty.x, valueProperty.y, valueProperty.z, valueProperty.w ); | |
| break; | |
| case 'c': | |
| _gl.uniform3f( locationProperty, valueProperty.r, valueProperty.g, valueProperty.b ); | |
| break; | |
| case 'm4': | |
| _gl.uniformMatrix4fv( locationProperty, false, valueProperty.elements ); | |
| break; | |
| } | |
| } | |
| } | |
| break; | |
| case 'iv1': | |
| // flat array of integers (JS or typed array) | |
| _gl.uniform1iv( location, value ); | |
| break; | |
| case 'iv': | |
| // flat array of integers with 3 x N size (JS or typed array) | |
| _gl.uniform3iv( location, value ); | |
| break; | |
| case 'fv1': | |
| // flat array of floats (JS or typed array) | |
| _gl.uniform1fv( location, value ); | |
| break; | |
| case 'fv': | |
| // flat array of floats with 3 x N size (JS or typed array) | |
| _gl.uniform3fv( location, value ); | |
| break; | |
| case 'v2v': | |
| // array of THREE.Vector2 | |
| if ( uniform._array === undefined ) { | |
| uniform._array = new Float32Array( 2 * value.length ); | |
| } | |
| for ( var i = 0, i2 = 0, il = value.length; i < il; i ++, i2 += 2 ) { | |
| uniform._array[ i2 + 0 ] = value[ i ].x; | |
| uniform._array[ i2 + 1 ] = value[ i ].y; | |
| } | |
| _gl.uniform2fv( location, uniform._array ); | |
| break; | |
| case 'v3v': | |
| // array of THREE.Vector3 | |
| if ( uniform._array === undefined ) { | |
| uniform._array = new Float32Array( 3 * value.length ); | |
| } | |
| for ( var i = 0, i3 = 0, il = value.length; i < il; i ++, i3 += 3 ) { | |
| uniform._array[ i3 + 0 ] = value[ i ].x; | |
| uniform._array[ i3 + 1 ] = value[ i ].y; | |
| uniform._array[ i3 + 2 ] = value[ i ].z; | |
| } | |
| _gl.uniform3fv( location, uniform._array ); | |
| break; | |
| case 'v4v': | |
| // array of THREE.Vector4 | |
| if ( uniform._array === undefined ) { | |
| uniform._array = new Float32Array( 4 * value.length ); | |
| } | |
| for ( var i = 0, i4 = 0, il = value.length; i < il; i ++, i4 += 4 ) { | |
| uniform._array[ i4 + 0 ] = value[ i ].x; | |
| uniform._array[ i4 + 1 ] = value[ i ].y; | |
| uniform._array[ i4 + 2 ] = value[ i ].z; | |
| uniform._array[ i4 + 3 ] = value[ i ].w; | |
| } | |
| _gl.uniform4fv( location, uniform._array ); | |
| break; | |
| case 'm2': | |
| // single THREE.Matrix2 | |
| _gl.uniformMatrix2fv( location, false, value.elements ); | |
| break; | |
| case 'm3': | |
| // single THREE.Matrix3 | |
| _gl.uniformMatrix3fv( location, false, value.elements ); | |
| break; | |
| case 'm3v': | |
| // array of THREE.Matrix3 | |
| if ( uniform._array === undefined ) { | |
| uniform._array = new Float32Array( 9 * value.length ); | |
| } | |
| for ( var i = 0, il = value.length; i < il; i ++ ) { | |
| value[ i ].flattenToArrayOffset( uniform._array, i * 9 ); | |
| } | |
| _gl.uniformMatrix3fv( location, false, uniform._array ); | |
| break; | |
| case 'm4': | |
| // single THREE.Matrix4 | |
| _gl.uniformMatrix4fv( location, false, value.elements ); | |
| break; | |
| case 'm4v': | |
| // array of THREE.Matrix4 | |
| if ( uniform._array === undefined ) { | |
| uniform._array = new Float32Array( 16 * value.length ); | |
| } | |
| for ( var i = 0, il = value.length; i < il; i ++ ) { | |
| value[ i ].flattenToArrayOffset( uniform._array, i * 16 ); | |
| } | |
| _gl.uniformMatrix4fv( location, false, uniform._array ); | |
| break; | |
| case 't': | |
| // single THREE.Texture (2d or cube) | |
| texture = value; | |
| textureUnit = getTextureUnit(); | |
| _gl.uniform1i( location, textureUnit ); | |
| if ( ! texture ) continue; | |
| if ( texture instanceof THREE.CubeTexture || | |
| ( Array.isArray( texture.image ) && texture.image.length === 6 ) ) { | |
| // CompressedTexture can have Array in image :/ | |
| setCubeTexture( texture, textureUnit ); | |
| } else if ( texture instanceof THREE.WebGLRenderTargetCube ) { | |
| setCubeTextureDynamic( texture.texture, textureUnit ); | |
| } else if ( texture instanceof THREE.WebGLRenderTarget ) { | |
| _this.setTexture( texture.texture, textureUnit ); | |
| } else { | |
| _this.setTexture( texture, textureUnit ); | |
| } | |
| break; | |
| case 'tv': | |
| // array of THREE.Texture (2d or cube) | |
| if ( uniform._array === undefined ) { | |
| uniform._array = []; | |
| } | |
| for ( var i = 0, il = uniform.value.length; i < il; i ++ ) { | |
| uniform._array[ i ] = getTextureUnit(); | |
| } | |
| _gl.uniform1iv( location, uniform._array ); | |
| for ( var i = 0, il = uniform.value.length; i < il; i ++ ) { | |
| texture = uniform.value[ i ]; | |
| textureUnit = uniform._array[ i ]; | |
| if ( ! texture ) continue; | |
| if ( texture instanceof THREE.CubeTexture || | |
| ( texture.image instanceof Array && texture.image.length === 6 ) ) { | |
| // CompressedTexture can have Array in image :/ | |
| setCubeTexture( texture, textureUnit ); | |
| } else if ( texture instanceof THREE.WebGLRenderTarget ) { | |
| _this.setTexture( texture.texture, textureUnit ); | |
| } else if ( texture instanceof THREE.WebGLRenderTargetCube ) { | |
| setCubeTextureDynamic( texture.texture, textureUnit ); | |
| } else { | |
| _this.setTexture( texture, textureUnit ); | |
| } | |
| } | |
| break; | |
| default: | |
| console.warn( 'THREE.WebGLRenderer: Unknown uniform type: ' + type ); | |
| } | |
| } | |
| } | |
| function setupLights ( lights, camera ) { | |
| var l, ll, light, | |
| r = 0, g = 0, b = 0, | |
| color, | |
| intensity, | |
| distance, | |
| viewMatrix = camera.matrixWorldInverse, | |
| directionalLength = 0, | |
| pointLength = 0, | |
| spotLength = 0, | |
| hemiLength = 0, | |
| shadowsLength = 0; | |
| _lights.shadowsPointLight = 0; | |
| for ( l = 0, ll = lights.length; l < ll; l ++ ) { | |
| light = lights[ l ]; | |
| color = light.color; | |
| intensity = light.intensity; | |
| distance = light.distance; | |
| if ( light instanceof THREE.AmbientLight ) { | |
| r += color.r * intensity; | |
| g += color.g * intensity; | |
| b += color.b * intensity; | |
| } else if ( light instanceof THREE.DirectionalLight ) { | |
| var uniforms = lightCache.get( light ); | |
| uniforms.color.copy( light.color ).multiplyScalar( light.intensity ); | |
| uniforms.direction.setFromMatrixPosition( light.matrixWorld ); | |
| _vector3.setFromMatrixPosition( light.target.matrixWorld ); | |
| uniforms.direction.sub( _vector3 ); | |
| uniforms.direction.transformDirection( viewMatrix ); | |
| uniforms.shadow = light.castShadow; | |
| if ( light.castShadow ) { | |
| uniforms.shadowBias = light.shadow.bias; | |
| uniforms.shadowRadius = light.shadow.radius; | |
| uniforms.shadowMapSize = light.shadow.mapSize; | |
| _lights.shadows[ shadowsLength ++ ] = light; | |
| } | |
| _lights.directionalShadowMap[ directionalLength ] = light.shadow.map; | |
| _lights.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix; | |
| _lights.directional[ directionalLength ++ ] = uniforms; | |
| } else if ( light instanceof THREE.SpotLight ) { | |
| var uniforms = lightCache.get( light ); | |
| uniforms.position.setFromMatrixPosition( light.matrixWorld ); | |
| uniforms.position.applyMatrix4( viewMatrix ); | |
| uniforms.color.copy( color ).multiplyScalar( intensity ); | |
| uniforms.distance = distance; | |
| uniforms.direction.setFromMatrixPosition( light.matrixWorld ); | |
| _vector3.setFromMatrixPosition( light.target.matrixWorld ); | |
| uniforms.direction.sub( _vector3 ); | |
| uniforms.direction.transformDirection( viewMatrix ); | |
| uniforms.angleCos = Math.cos( light.angle ); | |
| uniforms.exponent = light.exponent; | |
| uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay; | |
| uniforms.shadow = light.castShadow; | |
| if ( light.castShadow ) { | |
| uniforms.shadowBias = light.shadow.bias; | |
| uniforms.shadowRadius = light.shadow.radius; | |
| uniforms.shadowMapSize = light.shadow.mapSize; | |
| _lights.shadows[ shadowsLength ++ ] = light; | |
| } | |
| _lights.spotShadowMap[ spotLength ] = light.shadow.map; | |
| _lights.spotShadowMatrix[ spotLength ] = light.shadow.matrix; | |
| _lights.spot[ spotLength ++ ] = uniforms; | |
| } else if ( light instanceof THREE.PointLight ) { | |
| var uniforms = lightCache.get( light ); | |
| uniforms.position.setFromMatrixPosition( light.matrixWorld ); | |
| uniforms.position.applyMatrix4( viewMatrix ); | |
| uniforms.color.copy( light.color ).multiplyScalar( light.intensity ); | |
| uniforms.distance = light.distance; | |
| uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay; | |
| uniforms.shadow = light.castShadow; | |
| if ( light.castShadow ) { | |
| uniforms.shadowBias = light.shadow.bias; | |
| uniforms.shadowRadius = light.shadow.radius; | |
| uniforms.shadowMapSize = light.shadow.mapSize; | |
| _lights.shadows[ shadowsLength ++ ] = light; | |
| } | |
| _lights.pointShadowMap[ pointLength ] = light.shadow.map; | |
| if ( _lights.pointShadowMatrix[ pointLength ] === undefined ) { | |
| _lights.pointShadowMatrix[ pointLength ] = new THREE.Matrix4(); | |
| } | |
| // for point lights we set the shadow matrix to be a translation-only matrix | |
| // equal to inverse of the light's position | |
| _vector3.setFromMatrixPosition( light.matrixWorld ).negate(); | |
| _lights.pointShadowMatrix[ pointLength ].identity().setPosition( _vector3 ); | |
| _lights.point[ pointLength ++ ] = uniforms; | |
| } else if ( light instanceof THREE.HemisphereLight ) { | |
| var uniforms = lightCache.get( light ); | |
| uniforms.direction.setFromMatrixPosition( light.matrixWorld ); | |
| uniforms.direction.transformDirection( viewMatrix ); | |
| uniforms.direction.normalize(); | |
| uniforms.skyColor.copy( light.color ).multiplyScalar( intensity ); | |
| uniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity ); | |
| _lights.hemi[ hemiLength ++ ] = uniforms; | |
| } | |
| } | |
| _lights.ambient[ 0 ] = r; | |
| _lights.ambient[ 1 ] = g; | |
| _lights.ambient[ 2 ] = b; | |
| _lights.directional.length = directionalLength; | |
| _lights.spot.length = spotLength; | |
| _lights.point.length = pointLength; | |
| _lights.hemi.length = hemiLength; | |
| _lights.shadows.length = shadowsLength; | |
| _lights.hash = directionalLength + ',' + pointLength + ',' + spotLength + ',' + hemiLength + ',' + shadowsLength; | |
| } | |
| // GL state setting | |
| this.setFaceCulling = function ( cullFace, frontFaceDirection ) { | |
| if ( cullFace === THREE.CullFaceNone ) { | |
| state.disable( _gl.CULL_FACE ); | |
| } else { | |
| if ( frontFaceDirection === THREE.FrontFaceDirectionCW ) { | |
| _gl.frontFace( _gl.CW ); | |
| } else { | |
| _gl.frontFace( _gl.CCW ); | |
| } | |
| if ( cullFace === THREE.CullFaceBack ) { | |
| _gl.cullFace( _gl.BACK ); | |
| } else if ( cullFace === THREE.CullFaceFront ) { | |
| _gl.cullFace( _gl.FRONT ); | |
| } else { | |
| _gl.cullFace( _gl.FRONT_AND_BACK ); | |
| } | |
| state.enable( _gl.CULL_FACE ); | |
| } | |
| }; | |
| // Textures | |
| function setTextureParameters ( textureType, texture, isPowerOfTwoImage ) { | |
| var extension; | |
| if ( isPowerOfTwoImage ) { | |
| _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, paramThreeToGL( texture.wrapS ) ); | |
| _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, paramThreeToGL( texture.wrapT ) ); | |
| _gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, paramThreeToGL( texture.magFilter ) ); | |
| _gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, paramThreeToGL( texture.minFilter ) ); | |
| } else { | |
| _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE ); | |
| _gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE ); | |
| if ( texture.wrapS !== THREE.ClampToEdgeWrapping || texture.wrapT !== THREE.ClampToEdgeWrapping ) { | |
| console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.', texture ); | |
| } | |
| _gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterFallback( texture.magFilter ) ); | |
| _gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterFallback( texture.minFilter ) ); | |
| if ( texture.minFilter !== THREE.NearestFilter && texture.minFilter !== THREE.LinearFilter ) { | |
| console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.', texture ); | |
| } | |
| } | |
| extension = extensions.get( 'EXT_texture_filter_anisotropic' ); | |
| if ( extension ) { | |
| if ( texture.type === THREE.FloatType && extensions.get( 'OES_texture_float_linear' ) === null ) return; | |
| if ( texture.type === THREE.HalfFloatType && extensions.get( 'OES_texture_half_float_linear' ) === null ) return; | |
| if ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) { | |
| _gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, _this.getMaxAnisotropy() ) ); | |
| properties.get( texture ).__currentAnisotropy = texture.anisotropy; | |
| } | |
| } | |
| } | |
| function uploadTexture( textureProperties, texture, slot ) { | |
| if ( textureProperties.__webglInit === undefined ) { | |
| textureProperties.__webglInit = true; | |
| texture.addEventListener( 'dispose', onTextureDispose ); | |
| textureProperties.__webglTexture = _gl.createTexture(); | |
| _infoMemory.textures ++; | |
| } | |
| state.activeTexture( _gl.TEXTURE0 + slot ); | |
| state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture ); | |
| _gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY ); | |
| _gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha ); | |
| _gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment ); | |
| var image = clampToMaxSize( texture.image, capabilities.maxTextureSize ); | |
| if ( textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( image ) === false ) { | |
| image = makePowerOfTwo( image ); | |
| } | |
| var isPowerOfTwoImage = isPowerOfTwo( image ), | |
| glFormat = paramThreeToGL( texture.format ), | |
| glType = paramThreeToGL( texture.type ); | |
| setTextureParameters( _gl.TEXTURE_2D, texture, isPowerOfTwoImage ); | |
| var mipmap, mipmaps = texture.mipmaps; | |
| if ( texture instanceof THREE.DataTexture ) { | |
| // use manually created mipmaps if available | |
| // if there are no manual mipmaps | |
| // set 0 level mipmap and then use GL to generate other mipmap levels | |
| if ( mipmaps.length > 0 && isPowerOfTwoImage ) { | |
| for ( var i = 0, il = mipmaps.length; i < il; i ++ ) { | |
| mipmap = mipmaps[ i ]; | |
| state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data ); | |
| } | |
| texture.generateMipmaps = false; | |
| } else { | |
| state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, image.width, image.height, 0, glFormat, glType, image.data ); | |
| } | |
| } else if ( texture instanceof THREE.CompressedTexture ) { | |
| for ( var i = 0, il = mipmaps.length; i < il; i ++ ) { | |
| mipmap = mipmaps[ i ]; | |
| if ( texture.format !== THREE.RGBAFormat && texture.format !== THREE.RGBFormat ) { | |
| if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) { | |
| state.compressedTexImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, mipmap.data ); | |
| } else { | |
| console.warn( "THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()" ); | |
| } | |
| } else { | |
| state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data ); | |
| } | |
| } | |
| } else { | |
| // regular Texture (image, video, canvas) | |
| // use manually created mipmaps if available | |
| // if there are no manual mipmaps | |
| // set 0 level mipmap and then use GL to generate other mipmap levels | |
| if ( mipmaps.length > 0 && isPowerOfTwoImage ) { | |
| for ( var i = 0, il = mipmaps.length; i < il; i ++ ) { | |
| mipmap = mipmaps[ i ]; | |
| state.texImage2D( _gl.TEXTURE_2D, i, glFormat, glFormat, glType, mipmap ); | |
| } | |
| texture.generateMipmaps = false; | |
| } else { | |
| state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, glFormat, glType, image ); | |
| } | |
| } | |
| if ( texture.generateMipmaps && isPowerOfTwoImage ) _gl.generateMipmap( _gl.TEXTURE_2D ); | |
| textureProperties.__version = texture.version; | |
| if ( texture.onUpdate ) texture.onUpdate( texture ); | |
| } | |
| this.setTexture = function ( texture, slot ) { | |
| var textureProperties = properties.get( texture ); | |
| if ( texture.version > 0 && textureProperties.__version !== texture.version ) { | |
| var image = texture.image; | |
| if ( image === undefined ) { | |
| console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is undefined', texture ); | |
| return; | |
| } | |
| if ( image.complete === false ) { | |
| console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete', texture ); | |
| return; | |
| } | |
| uploadTexture( textureProperties, texture, slot ); | |
| return; | |
| } | |
| state.activeTexture( _gl.TEXTURE0 + slot ); | |
| state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture ); | |
| }; | |
| function clampToMaxSize ( image, maxSize ) { | |
| if ( image.width > maxSize || image.height > maxSize ) { | |
| // Warning: Scaling through the canvas will only work with images that use | |
| // premultiplied alpha. | |
| var scale = maxSize / Math.max( image.width, image.height ); | |
| var canvas = document.createElement( 'canvas' ); | |
| canvas.width = Math.floor( image.width * scale ); | |
| canvas.height = Math.floor( image.height * scale ); | |
| var context = canvas.getContext( '2d' ); | |
| context.drawImage( image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height ); | |
| console.warn( 'THREE.WebGLRenderer: image is too big (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image ); | |
| return canvas; | |
| } | |
| return image; | |
| } | |
| function isPowerOfTwo( image ) { | |
| return THREE.Math.isPowerOfTwo( image.width ) && THREE.Math.isPowerOfTwo( image.height ); | |
| } | |
| function textureNeedsPowerOfTwo( texture ) { | |
| if ( texture.wrapS !== THREE.ClampToEdgeWrapping || texture.wrapT !== THREE.ClampToEdgeWrapping ) return true; | |
| if ( texture.minFilter !== THREE.NearestFilter && texture.minFilter !== THREE.LinearFilter ) return true; | |
| return false; | |
| } | |
| function makePowerOfTwo( image ) { | |
| if ( image instanceof HTMLImageElement || image instanceof HTMLCanvasElement ) { | |
| var canvas = document.createElement( 'canvas' ); | |
| canvas.width = THREE.Math.nearestPowerOfTwo( image.width ); | |
| canvas.height = THREE.Math.nearestPowerOfTwo( image.height ); | |
| var context = canvas.getContext( '2d' ); | |
| context.drawImage( image, 0, 0, canvas.width, canvas.height ); | |
| console.warn( 'THREE.WebGLRenderer: image is not power of two (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image ); | |
| return canvas; | |
| } | |
| return image; | |
| } | |
| function setCubeTexture ( texture, slot ) { | |
| var textureProperties = properties.get( texture ); | |
| if ( texture.image.length === 6 ) { | |
| if ( texture.version > 0 && textureProperties.__version !== texture.version ) { | |
| if ( ! textureProperties.__image__webglTextureCube ) { | |
| texture.addEventListener( 'dispose', onTextureDispose ); | |
| textureProperties.__image__webglTextureCube = _gl.createTexture(); | |
| _infoMemory.textures ++; | |
| } | |
| state.activeTexture( _gl.TEXTURE0 + slot ); | |
| state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube ); | |
| _gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY ); | |
| var isCompressed = texture instanceof THREE.CompressedTexture; | |
| var isDataTexture = texture.image[ 0 ] instanceof THREE.DataTexture; | |
| var cubeImage = []; | |
| for ( var i = 0; i < 6; i ++ ) { | |
| if ( _this.autoScaleCubemaps && ! isCompressed && ! isDataTexture ) { | |
| cubeImage[ i ] = clampToMaxSize( texture.image[ i ], capabilities.maxCubemapSize ); | |
| } else { | |
| cubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ]; | |
| } | |
| } | |
| var image = cubeImage[ 0 ], | |
| isPowerOfTwoImage = isPowerOfTwo( image ), | |
| glFormat = paramThreeToGL( texture.format ), | |
| glType = paramThreeToGL( texture.type ); | |
| setTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, isPowerOfTwoImage ); | |
| for ( var i = 0; i < 6; i ++ ) { | |
| if ( ! isCompressed ) { | |
| if ( isDataTexture ) { | |
| state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data ); | |
| } else { | |
| state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, glFormat, glType, cubeImage[ i ] ); | |
| } | |
| } else { | |
| var mipmap, mipmaps = cubeImage[ i ].mipmaps; | |
| for ( var j = 0, jl = mipmaps.length; j < jl; j ++ ) { | |
| mipmap = mipmaps[ j ]; | |
| if ( texture.format !== THREE.RGBAFormat && texture.format !== THREE.RGBFormat ) { | |
| if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) { | |
| state.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, mipmap.data ); | |
| } else { | |
| console.warn( "THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setCubeTexture()" ); | |
| } | |
| } else { | |
| state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data ); | |
| } | |
| } | |
| } | |
| } | |
| if ( texture.generateMipmaps && isPowerOfTwoImage ) { | |
| _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP ); | |
| } | |
| textureProperties.__version = texture.version; | |
| if ( texture.onUpdate ) texture.onUpdate( texture ); | |
| } else { | |
| state.activeTexture( _gl.TEXTURE0 + slot ); | |
| state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube ); | |
| } | |
| } | |
| } | |
| function setCubeTextureDynamic ( texture, slot ) { | |
| state.activeTexture( _gl.TEXTURE0 + slot ); | |
| state.bindTexture( _gl.TEXTURE_CUBE_MAP, properties.get( texture ).__webglTexture ); | |
| } | |
| // Render targets | |
| // Setup storage for target texture and bind it to correct framebuffer | |
| function setupFrameBufferTexture ( framebuffer, renderTarget, attachment, textureTarget ) { | |
| var glFormat = paramThreeToGL( renderTarget.texture.format ); | |
| var glType = paramThreeToGL( renderTarget.texture.type ); | |
| state.texImage2D( textureTarget, 0, glFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null ); | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer ); | |
| _gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( renderTarget.texture ).__webglTexture, 0 ); | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, null ); | |
| } | |
| // Setup storage for internal depth/stencil buffers and bind to correct framebuffer | |
| function setupRenderBufferStorage ( renderbuffer, renderTarget ) { | |
| _gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer ); | |
| if ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) { | |
| _gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_COMPONENT16, renderTarget.width, renderTarget.height ); | |
| _gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer ); | |
| } else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) { | |
| _gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height ); | |
| _gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer ); | |
| } else { | |
| // FIXME: We don't support !depth !stencil | |
| _gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.RGBA4, renderTarget.width, renderTarget.height ); | |
| } | |
| _gl.bindRenderbuffer( _gl.RENDERBUFFER, null ); | |
| } | |
| // Setup GL resources for a non-texture depth buffer | |
| function setupDepthRenderbuffer( renderTarget ) { | |
| var renderTargetProperties = properties.get( renderTarget ); | |
| var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube ); | |
| if ( isCube ) { | |
| renderTargetProperties.__webglDepthbuffer = []; | |
| for ( var i = 0; i < 6; i ++ ) { | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] ); | |
| renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer(); | |
| setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget ); | |
| } | |
| } else { | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer ); | |
| renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer(); | |
| setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget ); | |
| } | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, null ); | |
| } | |
| // Set up GL resources for the render target | |
| function setupRenderTarget( renderTarget ) { | |
| var renderTargetProperties = properties.get( renderTarget ); | |
| var textureProperties = properties.get( renderTarget.texture ); | |
| renderTarget.addEventListener( 'dispose', onRenderTargetDispose ); | |
| textureProperties.__webglTexture = _gl.createTexture(); | |
| _infoMemory.textures ++; | |
| var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube ); | |
| var isTargetPowerOfTwo = THREE.Math.isPowerOfTwo( renderTarget.width ) && THREE.Math.isPowerOfTwo( renderTarget.height ); | |
| // Setup framebuffer | |
| if ( isCube ) { | |
| renderTargetProperties.__webglFramebuffer = []; | |
| for ( var i = 0; i < 6; i ++ ) { | |
| renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer(); | |
| } | |
| } else { | |
| renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer(); | |
| } | |
| // Setup color buffer | |
| if ( isCube ) { | |
| state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture ); | |
| setTextureParameters( _gl.TEXTURE_CUBE_MAP, renderTarget.texture, isTargetPowerOfTwo ); | |
| for ( var i = 0; i < 6; i ++ ) { | |
| setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i ); | |
| } | |
| if ( renderTarget.texture.generateMipmaps && isTargetPowerOfTwo ) _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP ); | |
| state.bindTexture( _gl.TEXTURE_CUBE_MAP, null ); | |
| } else { | |
| state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture ); | |
| setTextureParameters( _gl.TEXTURE_2D, renderTarget.texture, isTargetPowerOfTwo ); | |
| setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D ); | |
| if ( renderTarget.texture.generateMipmaps && isTargetPowerOfTwo ) _gl.generateMipmap( _gl.TEXTURE_2D ); | |
| state.bindTexture( _gl.TEXTURE_2D, null ); | |
| } | |
| // Setup depth and stencil buffers | |
| if ( renderTarget.depthBuffer ) { | |
| setupDepthRenderbuffer( renderTarget ); | |
| } | |
| } | |
| this.setRenderTarget = function ( renderTarget ) { | |
| _currentRenderTarget = renderTarget; | |
| if ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) { | |
| setupRenderTarget( renderTarget ); | |
| } | |
| var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube ); | |
| var framebuffer; | |
| if ( renderTarget ) { | |
| var renderTargetProperties = properties.get( renderTarget ); | |
| if ( isCube ) { | |
| framebuffer = renderTargetProperties.__webglFramebuffer[ renderTarget.activeCubeFace ]; | |
| } else { | |
| framebuffer = renderTargetProperties.__webglFramebuffer; | |
| } | |
| _currentScissor.copy( renderTarget.scissor ); | |
| _currentScissorTest = renderTarget.scissorTest; | |
| _currentViewport.copy( renderTarget.viewport ); | |
| } else { | |
| framebuffer = null; | |
| _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ); | |
| _currentScissorTest = _scissorTest; | |
| _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ); | |
| } | |
| if ( _currentFramebuffer !== framebuffer ) { | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer ); | |
| _currentFramebuffer = framebuffer; | |
| } | |
| state.scissor( _currentScissor ); | |
| state.setScissorTest( _currentScissorTest ); | |
| state.viewport( _currentViewport ); | |
| if ( isCube ) { | |
| var textureProperties = properties.get( renderTarget.texture ); | |
| _gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + renderTarget.activeCubeFace, textureProperties.__webglTexture, 0 ); | |
| } | |
| }; | |
| this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer ) { | |
| if ( renderTarget instanceof THREE.WebGLRenderTarget === false ) { | |
| console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' ); | |
| return; | |
| } | |
| var framebuffer = properties.get( renderTarget ).__webglFramebuffer; | |
| if ( framebuffer ) { | |
| var restore = false; | |
| if ( framebuffer !== _currentFramebuffer ) { | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer ); | |
| restore = true; | |
| } | |
| try { | |
| var texture = renderTarget.texture; | |
| if ( texture.format !== THREE.RGBAFormat | |
| && paramThreeToGL( texture.format ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) { | |
| console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' ); | |
| return; | |
| } | |
| if ( texture.type !== THREE.UnsignedByteType | |
| && paramThreeToGL( texture.type ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) | |
| && ! ( texture.type === THREE.FloatType && extensions.get( 'WEBGL_color_buffer_float' ) ) | |
| && ! ( texture.type === THREE.HalfFloatType && extensions.get( 'EXT_color_buffer_half_float' ) ) ) { | |
| console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' ); | |
| return; | |
| } | |
| if ( _gl.checkFramebufferStatus( _gl.FRAMEBUFFER ) === _gl.FRAMEBUFFER_COMPLETE ) { | |
| _gl.readPixels( x, y, width, height, paramThreeToGL( texture.format ), paramThreeToGL( texture.type ), buffer ); | |
| } else { | |
| console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.' ); | |
| } | |
| } finally { | |
| if ( restore ) { | |
| _gl.bindFramebuffer( _gl.FRAMEBUFFER, _currentFramebuffer ); | |
| } | |
| } | |
| } | |
| }; | |
| function updateRenderTargetMipmap( renderTarget ) { | |
| var target = renderTarget instanceof THREE.WebGLRenderTargetCube ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D; | |
| var texture = properties.get( renderTarget.texture ).__webglTexture; | |
| state.bindTexture( target, texture ); | |
| _gl.generateMipmap( target ); | |
| state.bindTexture( target, null ); | |
| } | |
| // Fallback filters for non-power-of-2 textures | |
| function filterFallback ( f ) { | |
| if ( f === THREE.NearestFilter || f === THREE.NearestMipMapNearestFilter || f === THREE.NearestMipMapLinearFilter ) { | |
| return _gl.NEAREST; | |
| } | |
| return _gl.LINEAR; | |
| } | |
| // Map three.js constants to WebGL constants | |
| function paramThreeToGL ( p ) { | |
| var extension; | |
| if ( p === THREE.RepeatWrapping ) return _gl.REPEAT; | |
| if ( p === THREE.ClampToEdgeWrapping ) return _gl.CLAMP_TO_EDGE; | |
| if ( p === THREE.MirroredRepeatWrapping ) return _gl.MIRRORED_REPEAT; | |
| if ( p === THREE.NearestFilter ) return _gl.NEAREST; | |
| if ( p === THREE.NearestMipMapNearestFilter ) return _gl.NEAREST_MIPMAP_NEAREST; | |
| if ( p === THREE.NearestMipMapLinearFilter ) return _gl.NEAREST_MIPMAP_LINEAR; | |
| if ( p === THREE.LinearFilter ) return _gl.LINEAR; | |
| if ( p === THREE.LinearMipMapNearestFilter ) return _gl.LINEAR_MIPMAP_NEAREST; | |
| if ( p === THREE.LinearMipMapLinearFilter ) return _gl.LINEAR_MIPMAP_LINEAR; | |
| if ( p === THREE.UnsignedByteType ) return _gl.UNSIGNED_BYTE; | |
| if ( p === THREE.UnsignedShort4444Type ) return _gl.UNSIGNED_SHORT_4_4_4_4; | |
| if ( p === THREE.UnsignedShort5551Type ) return _gl.UNSIGNED_SHORT_5_5_5_1; | |
| if ( p === THREE.UnsignedShort565Type ) return _gl.UNSIGNED_SHORT_5_6_5; | |
| if ( p === THREE.ByteType ) return _gl.BYTE; | |
| if ( p === THREE.ShortType ) return _gl.SHORT; | |
| if ( p === THREE.UnsignedShortType ) return _gl.UNSIGNED_SHORT; | |
| if ( p === THREE.IntType ) return _gl.INT; | |
| if ( p === THREE.UnsignedIntType ) return _gl.UNSIGNED_INT; | |
| if ( p === THREE.FloatType ) return _gl.FLOAT; | |
| extension = extensions.get( 'OES_texture_half_float' ); | |
| if ( extension !== null ) { | |
| if ( p === THREE.HalfFloatType ) return extension.HALF_FLOAT_OES; | |
| } | |
| if ( p === THREE.AlphaFormat ) return _gl.ALPHA; | |
| if ( p === THREE.RGBFormat ) return _gl.RGB; | |
| if ( p === THREE.RGBAFormat ) return _gl.RGBA; | |
| if ( p === THREE.LuminanceFormat ) return _gl.LUMINANCE; | |
| if ( p === THREE.LuminanceAlphaFormat ) return _gl.LUMINANCE_ALPHA; | |
| if ( p === THREE.AddEquation ) return _gl.FUNC_ADD; | |
| if ( p === THREE.SubtractEquation ) return _gl.FUNC_SUBTRACT; | |
| if ( p === THREE.ReverseSubtractEquation ) return _gl.FUNC_REVERSE_SUBTRACT; | |
| if ( p === THREE.ZeroFactor ) return _gl.ZERO; | |
| if ( p === THREE.OneFactor ) return _gl.ONE; | |
| if ( p === THREE.SrcColorFactor ) return _gl.SRC_COLOR; | |
| if ( p === THREE.OneMinusSrcColorFactor ) return _gl.ONE_MINUS_SRC_COLOR; | |
| if ( p === THREE.SrcAlphaFactor ) return _gl.SRC_ALPHA; | |
| if ( p === THREE.OneMinusSrcAlphaFactor ) return _gl.ONE_MINUS_SRC_ALPHA; | |
| if ( p === THREE.DstAlphaFactor ) return _gl.DST_ALPHA; | |
| if ( p === THREE.OneMinusDstAlphaFactor ) return _gl.ONE_MINUS_DST_ALPHA; | |
| if ( p === THREE.DstColorFactor ) return _gl.DST_COLOR; | |
| if ( p === THREE.OneMinusDstColorFactor ) return _gl.ONE_MINUS_DST_COLOR; | |
| if ( p === THREE.SrcAlphaSaturateFactor ) return _gl.SRC_ALPHA_SATURATE; | |
| extension = extensions.get( 'WEBGL_compressed_texture_s3tc' ); | |
| if ( extension !== null ) { | |
| if ( p === THREE.RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT; | |
| if ( p === THREE.RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT; | |
| if ( p === THREE.RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT; | |
| if ( p === THREE.RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT; | |
| } | |
| extension = extensions.get( 'WEBGL_compressed_texture_pvrtc' ); | |
| if ( extension !== null ) { | |
| if ( p === THREE.RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG; | |
| if ( p === THREE.RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG; | |
| if ( p === THREE.RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; | |
| if ( p === THREE.RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG; | |
| } | |
| extension = extensions.get( 'WEBGL_compressed_texture_etc1' ); | |
| if ( extension !== null ) { | |
| if ( p === THREE.RGB_ETC1_Format ) return extension.COMPRESSED_RGB_ETC1_WEBGL; | |
| } | |
| extension = extensions.get( 'EXT_blend_minmax' ); | |
| if ( extension !== null ) { | |
| if ( p === THREE.MinEquation ) return extension.MIN_EXT; | |
| if ( p === THREE.MaxEquation ) return extension.MAX_EXT; | |
| } | |
| return 0; | |
| } | |
| }; | |
| // File:src/renderers/WebGLRenderTarget.js | |
| /** | |
| * @author szimek / https://github.com/szimek/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author Marius Kintel / https://github.com/kintel | |
| */ | |
| /* | |
| In options, we can specify: | |
| * Texture parameters for an auto-generated target texture | |
| * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers | |
| */ | |
| THREE.WebGLRenderTarget = function ( width, height, options ) { | |
| this.uuid = THREE.Math.generateUUID(); | |
| this.width = width; | |
| this.height = height; | |
| this.scissor = new THREE.Vector4( 0, 0, width, height ); | |
| this.scissorTest = false; | |
| this.viewport = new THREE.Vector4( 0, 0, width, height ); | |
| options = options || {}; | |
| if ( options.minFilter === undefined ) options.minFilter = THREE.LinearFilter; | |
| this.texture = new THREE.Texture( undefined, undefined, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy ); | |
| this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true; | |
| this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true; | |
| }; | |
| THREE.WebGLRenderTarget.prototype = { | |
| constructor: THREE.WebGLRenderTarget, | |
| setSize: function ( width, height ) { | |
| if ( this.width !== width || this.height !== height ) { | |
| this.width = width; | |
| this.height = height; | |
| this.dispose(); | |
| } | |
| this.viewport.set( 0, 0, width, height ); | |
| this.scissor.set( 0, 0, width, height ); | |
| }, | |
| clone: function () { | |
| return new this.constructor().copy( this ); | |
| }, | |
| copy: function ( source ) { | |
| this.width = source.width; | |
| this.height = source.height; | |
| this.viewport.copy( source.viewport ); | |
| this.texture = source.texture.clone(); | |
| this.depthBuffer = source.depthBuffer; | |
| this.stencilBuffer = source.stencilBuffer; | |
| this.shareDepthFrom = source.shareDepthFrom; | |
| return this; | |
| }, | |
| dispose: function () { | |
| this.dispatchEvent( { type: 'dispose' } ); | |
| } | |
| }; | |
| THREE.EventDispatcher.prototype.apply( THREE.WebGLRenderTarget.prototype ); | |
| // File:src/renderers/WebGLRenderTargetCube.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com | |
| */ | |
| THREE.WebGLRenderTargetCube = function ( width, height, options ) { | |
| THREE.WebGLRenderTarget.call( this, width, height, options ); | |
| this.activeCubeFace = 0; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5 | |
| }; | |
| THREE.WebGLRenderTargetCube.prototype = Object.create( THREE.WebGLRenderTarget.prototype ); | |
| THREE.WebGLRenderTargetCube.prototype.constructor = THREE.WebGLRenderTargetCube; | |
| // File:src/renderers/webgl/WebGLBufferRenderer.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLBufferRenderer = function ( _gl, extensions, _infoRender ) { | |
| var mode; | |
| function setMode( value ) { | |
| mode = value; | |
| } | |
| function render( start, count ) { | |
| _gl.drawArrays( mode, start, count ); | |
| _infoRender.calls ++; | |
| _infoRender.vertices += count; | |
| if ( mode === _gl.TRIANGLES ) _infoRender.faces += count / 3; | |
| } | |
| function renderInstances( geometry ) { | |
| var extension = extensions.get( 'ANGLE_instanced_arrays' ); | |
| if ( extension === null ) { | |
| console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' ); | |
| return; | |
| } | |
| var position = geometry.attributes.position; | |
| var count = 0; | |
| if ( position instanceof THREE.InterleavedBufferAttribute ) { | |
| count = position.data.count; | |
| extension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount ); | |
| } else { | |
| count = position.count; | |
| extension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount ); | |
| } | |
| _infoRender.calls ++; | |
| _infoRender.vertices += count * geometry.maxInstancedCount; | |
| if ( mode === _gl.TRIANGLES ) _infoRender.faces += geometry.maxInstancedCount * count / 3; | |
| } | |
| this.setMode = setMode; | |
| this.render = render; | |
| this.renderInstances = renderInstances; | |
| }; | |
| // File:src/renderers/webgl/WebGLIndexedBufferRenderer.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLIndexedBufferRenderer = function ( _gl, extensions, _infoRender ) { | |
| var mode; | |
| function setMode( value ) { | |
| mode = value; | |
| } | |
| var type, size; | |
| function setIndex( index ) { | |
| if ( index.array instanceof Uint32Array && extensions.get( 'OES_element_index_uint' ) ) { | |
| type = _gl.UNSIGNED_INT; | |
| size = 4; | |
| } else { | |
| type = _gl.UNSIGNED_SHORT; | |
| size = 2; | |
| } | |
| } | |
| function render( start, count ) { | |
| _gl.drawElements( mode, count, type, start * size ); | |
| _infoRender.calls ++; | |
| _infoRender.vertices += count; | |
| if ( mode === _gl.TRIANGLES ) _infoRender.faces += count / 3; | |
| } | |
| function renderInstances( geometry, start, count ) { | |
| var extension = extensions.get( 'ANGLE_instanced_arrays' ); | |
| if ( extension === null ) { | |
| console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' ); | |
| return; | |
| } | |
| extension.drawElementsInstancedANGLE( mode, count, type, start * size, geometry.maxInstancedCount ); | |
| _infoRender.calls ++; | |
| _infoRender.vertices += count * geometry.maxInstancedCount; | |
| if ( mode === _gl.TRIANGLES ) _infoRender.faces += geometry.maxInstancedCount * count / 3; | |
| } | |
| this.setMode = setMode; | |
| this.setIndex = setIndex; | |
| this.render = render; | |
| this.renderInstances = renderInstances; | |
| }; | |
| // File:src/renderers/webgl/WebGLExtensions.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLExtensions = function ( gl ) { | |
| var extensions = {}; | |
| this.get = function ( name ) { | |
| if ( extensions[ name ] !== undefined ) { | |
| return extensions[ name ]; | |
| } | |
| var extension; | |
| switch ( name ) { | |
| case 'EXT_texture_filter_anisotropic': | |
| extension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' ); | |
| break; | |
| case 'WEBGL_compressed_texture_s3tc': | |
| extension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' ); | |
| break; | |
| case 'WEBGL_compressed_texture_pvrtc': | |
| extension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' ); | |
| break; | |
| case 'WEBGL_compressed_texture_etc1': | |
| extension = gl.getExtension( 'WEBGL_compressed_texture_etc1' ); | |
| break; | |
| default: | |
| extension = gl.getExtension( name ); | |
| } | |
| if ( extension === null ) { | |
| console.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' ); | |
| } | |
| extensions[ name ] = extension; | |
| return extension; | |
| }; | |
| }; | |
| // File:src/renderers/webgl/WebGLCapabilities.js | |
| THREE.WebGLCapabilities = function ( gl, extensions, parameters ) { | |
| function getMaxPrecision( precision ) { | |
| if ( precision === 'highp' ) { | |
| if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 && | |
| gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) { | |
| return 'highp'; | |
| } | |
| precision = 'mediump'; | |
| } | |
| if ( precision === 'mediump' ) { | |
| if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 && | |
| gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) { | |
| return 'mediump'; | |
| } | |
| } | |
| return 'lowp'; | |
| } | |
| this.getMaxPrecision = getMaxPrecision; | |
| this.precision = parameters.precision !== undefined ? parameters.precision : 'highp', | |
| this.logarithmicDepthBuffer = parameters.logarithmicDepthBuffer !== undefined ? parameters.logarithmicDepthBuffer : false; | |
| this.maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS ); | |
| this.maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS ); | |
| this.maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE ); | |
| this.maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE ); | |
| this.maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS ); | |
| this.maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS ); | |
| this.maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS ); | |
| this.maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS ); | |
| this.vertexTextures = this.maxVertexTextures > 0; | |
| this.floatFragmentTextures = !! extensions.get( 'OES_texture_float' ); | |
| this.floatVertexTextures = this.vertexTextures && this.floatFragmentTextures; | |
| var _maxPrecision = getMaxPrecision( this.precision ); | |
| if ( _maxPrecision !== this.precision ) { | |
| console.warn( 'THREE.WebGLRenderer:', this.precision, 'not supported, using', _maxPrecision, 'instead.' ); | |
| this.precision = _maxPrecision; | |
| } | |
| if ( this.logarithmicDepthBuffer ) { | |
| this.logarithmicDepthBuffer = !! extensions.get( 'EXT_frag_depth' ); | |
| } | |
| }; | |
| // File:src/renderers/webgl/WebGLGeometries.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLGeometries = function ( gl, properties, info ) { | |
| var geometries = {}; | |
| function get( object ) { | |
| var geometry = object.geometry; | |
| if ( geometries[ geometry.id ] !== undefined ) { | |
| return geometries[ geometry.id ]; | |
| } | |
| geometry.addEventListener( 'dispose', onGeometryDispose ); | |
| var buffergeometry; | |
| if ( geometry instanceof THREE.BufferGeometry ) { | |
| buffergeometry = geometry; | |
| } else if ( geometry instanceof THREE.Geometry ) { | |
| if ( geometry._bufferGeometry === undefined ) { | |
| geometry._bufferGeometry = new THREE.BufferGeometry().setFromObject( object ); | |
| } | |
| buffergeometry = geometry._bufferGeometry; | |
| } | |
| geometries[ geometry.id ] = buffergeometry; | |
| info.memory.geometries ++; | |
| return buffergeometry; | |
| } | |
| function onGeometryDispose( event ) { | |
| var geometry = event.target; | |
| var buffergeometry = geometries[ geometry.id ]; | |
| if ( buffergeometry.index !== null ) { | |
| deleteAttribute( buffergeometry.index ); | |
| } | |
| deleteAttributes( buffergeometry.attributes ); | |
| geometry.removeEventListener( 'dispose', onGeometryDispose ); | |
| delete geometries[ geometry.id ]; | |
| // TODO | |
| var property = properties.get( geometry ); | |
| if ( property.wireframe ) { | |
| deleteAttribute( property.wireframe ); | |
| } | |
| properties.delete( geometry ); | |
| var bufferproperty = properties.get( buffergeometry ); | |
| if ( bufferproperty.wireframe ) { | |
| deleteAttribute( bufferproperty.wireframe ); | |
| } | |
| properties.delete( buffergeometry ); | |
| // | |
| info.memory.geometries --; | |
| } | |
| function getAttributeBuffer( attribute ) { | |
| if ( attribute instanceof THREE.InterleavedBufferAttribute ) { | |
| return properties.get( attribute.data ).__webglBuffer; | |
| } | |
| return properties.get( attribute ).__webglBuffer; | |
| } | |
| function deleteAttribute( attribute ) { | |
| var buffer = getAttributeBuffer( attribute ); | |
| if ( buffer !== undefined ) { | |
| gl.deleteBuffer( buffer ); | |
| removeAttributeBuffer( attribute ); | |
| } | |
| } | |
| function deleteAttributes( attributes ) { | |
| for ( var name in attributes ) { | |
| deleteAttribute( attributes[ name ] ); | |
| } | |
| } | |
| function removeAttributeBuffer( attribute ) { | |
| if ( attribute instanceof THREE.InterleavedBufferAttribute ) { | |
| properties.delete( attribute.data ); | |
| } else { | |
| properties.delete( attribute ); | |
| } | |
| } | |
| this.get = get; | |
| }; | |
| // File:src/renderers/webgl/WebGLLights.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLLights = function () { | |
| var lights = {}; | |
| this.get = function ( light ) { | |
| if ( lights[ light.id ] !== undefined ) { | |
| return lights[ light.id ]; | |
| } | |
| var uniforms; | |
| switch ( light.type ) { | |
| case 'DirectionalLight': | |
| uniforms = { | |
| direction: new THREE.Vector3(), | |
| color: new THREE.Color(), | |
| shadow: false, | |
| shadowBias: 0, | |
| shadowRadius: 1, | |
| shadowMapSize: new THREE.Vector2() | |
| }; | |
| break; | |
| case 'SpotLight': | |
| uniforms = { | |
| position: new THREE.Vector3(), | |
| direction: new THREE.Vector3(), | |
| color: new THREE.Color(), | |
| distance: 0, | |
| angleCos: 0, | |
| exponent: 0, | |
| decay: 0, | |
| shadow: false, | |
| shadowBias: 0, | |
| shadowRadius: 1, | |
| shadowMapSize: new THREE.Vector2() | |
| }; | |
| break; | |
| case 'PointLight': | |
| uniforms = { | |
| position: new THREE.Vector3(), | |
| color: new THREE.Color(), | |
| distance: 0, | |
| decay: 0, | |
| shadow: false, | |
| shadowBias: 0, | |
| shadowRadius: 1, | |
| shadowMapSize: new THREE.Vector2() | |
| }; | |
| break; | |
| case 'HemisphereLight': | |
| uniforms = { | |
| direction: new THREE.Vector3(), | |
| skyColor: new THREE.Color(), | |
| groundColor: new THREE.Color() | |
| }; | |
| break; | |
| } | |
| lights[ light.id ] = uniforms; | |
| return uniforms; | |
| }; | |
| }; | |
| // File:src/renderers/webgl/WebGLObjects.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLObjects = function ( gl, properties, info ) { | |
| var geometries = new THREE.WebGLGeometries( gl, properties, info ); | |
| // | |
| function update( object ) { | |
| // TODO: Avoid updating twice (when using shadowMap). Maybe add frame counter. | |
| var geometry = geometries.get( object ); | |
| if ( object.geometry instanceof THREE.Geometry ) { | |
| geometry.updateFromObject( object ); | |
| } | |
| var index = geometry.index; | |
| var attributes = geometry.attributes; | |
| if ( index !== null ) { | |
| updateAttribute( index, gl.ELEMENT_ARRAY_BUFFER ); | |
| } | |
| for ( var name in attributes ) { | |
| updateAttribute( attributes[ name ], gl.ARRAY_BUFFER ); | |
| } | |
| // morph targets | |
| var morphAttributes = geometry.morphAttributes; | |
| for ( var name in morphAttributes ) { | |
| var array = morphAttributes[ name ]; | |
| for ( var i = 0, l = array.length; i < l; i ++ ) { | |
| updateAttribute( array[ i ], gl.ARRAY_BUFFER ); | |
| } | |
| } | |
| return geometry; | |
| } | |
| function updateAttribute( attribute, bufferType ) { | |
| var data = ( attribute instanceof THREE.InterleavedBufferAttribute ) ? attribute.data : attribute; | |
| var attributeProperties = properties.get( data ); | |
| if ( attributeProperties.__webglBuffer === undefined ) { | |
| createBuffer( attributeProperties, data, bufferType ); | |
| } else if ( attributeProperties.version !== data.version ) { | |
| updateBuffer( attributeProperties, data, bufferType ); | |
| } | |
| } | |
| function createBuffer( attributeProperties, data, bufferType ) { | |
| attributeProperties.__webglBuffer = gl.createBuffer(); | |
| gl.bindBuffer( bufferType, attributeProperties.__webglBuffer ); | |
| var usage = data.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW; | |
| gl.bufferData( bufferType, data.array, usage ); | |
| attributeProperties.version = data.version; | |
| } | |
| function updateBuffer( attributeProperties, data, bufferType ) { | |
| gl.bindBuffer( bufferType, attributeProperties.__webglBuffer ); | |
| if ( data.dynamic === false || data.updateRange.count === - 1 ) { | |
| // Not using update ranges | |
| gl.bufferSubData( bufferType, 0, data.array ); | |
| } else if ( data.updateRange.count === 0 ) { | |
| console.error( 'THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually.' ); | |
| } else { | |
| gl.bufferSubData( bufferType, data.updateRange.offset * data.array.BYTES_PER_ELEMENT, | |
| data.array.subarray( data.updateRange.offset, data.updateRange.offset + data.updateRange.count ) ); | |
| data.updateRange.count = 0; // reset range | |
| } | |
| attributeProperties.version = data.version; | |
| } | |
| function getAttributeBuffer( attribute ) { | |
| if ( attribute instanceof THREE.InterleavedBufferAttribute ) { | |
| return properties.get( attribute.data ).__webglBuffer; | |
| } | |
| return properties.get( attribute ).__webglBuffer; | |
| } | |
| function getWireframeAttribute( geometry ) { | |
| var property = properties.get( geometry ); | |
| if ( property.wireframe !== undefined ) { | |
| return property.wireframe; | |
| } | |
| var indices = []; | |
| var index = geometry.index; | |
| var attributes = geometry.attributes; | |
| var position = attributes.position; | |
| // console.time( 'wireframe' ); | |
| if ( index !== null ) { | |
| var edges = {}; | |
| var array = index.array; | |
| for ( var i = 0, l = array.length; i < l; i += 3 ) { | |
| var a = array[ i + 0 ]; | |
| var b = array[ i + 1 ]; | |
| var c = array[ i + 2 ]; | |
| if ( checkEdge( edges, a, b ) ) indices.push( a, b ); | |
| if ( checkEdge( edges, b, c ) ) indices.push( b, c ); | |
| if ( checkEdge( edges, c, a ) ) indices.push( c, a ); | |
| } | |
| } else { | |
| var array = attributes.position.array; | |
| for ( var i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) { | |
| var a = i + 0; | |
| var b = i + 1; | |
| var c = i + 2; | |
| indices.push( a, b, b, c, c, a ); | |
| } | |
| } | |
| // console.timeEnd( 'wireframe' ); | |
| var TypeArray = position.count > 65535 ? Uint32Array : Uint16Array; | |
| var attribute = new THREE.BufferAttribute( new TypeArray( indices ), 1 ); | |
| updateAttribute( attribute, gl.ELEMENT_ARRAY_BUFFER ); | |
| property.wireframe = attribute; | |
| return attribute; | |
| } | |
| function checkEdge( edges, a, b ) { | |
| if ( a > b ) { | |
| var tmp = a; | |
| a = b; | |
| b = tmp; | |
| } | |
| var list = edges[ a ]; | |
| if ( list === undefined ) { | |
| edges[ a ] = [ b ]; | |
| return true; | |
| } else if ( list.indexOf( b ) === -1 ) { | |
| list.push( b ); | |
| return true; | |
| } | |
| return false; | |
| } | |
| this.getAttributeBuffer = getAttributeBuffer; | |
| this.getWireframeAttribute = getWireframeAttribute; | |
| this.update = update; | |
| }; | |
| // File:src/renderers/webgl/WebGLProgram.js | |
| THREE.WebGLProgram = ( function () { | |
| var programIdCount = 0; | |
| // TODO: Combine the regex | |
| var structRe = /^([\w\d_]+)\.([\w\d_]+)$/; | |
| var arrayStructRe = /^([\w\d_]+)\[(\d+)\]\.([\w\d_]+)$/; | |
| var arrayRe = /^([\w\d_]+)\[0\]$/; | |
| function generateExtensions( extensions, parameters, rendererExtensions ) { | |
| extensions = extensions || {}; | |
| var chunks = [ | |
| ( extensions.derivatives || parameters.bumpMap || parameters.normalMap || parameters.flatShading ) ? '#extension GL_OES_standard_derivatives : enable' : '', | |
| ( extensions.fragDepth || parameters.logarithmicDepthBuffer ) && rendererExtensions.get( 'EXT_frag_depth' ) ? '#extension GL_EXT_frag_depth : enable' : '', | |
| ( extensions.drawBuffers ) && rendererExtensions.get( 'WEBGL_draw_buffers' ) ? '#extension GL_EXT_draw_buffers : require' : '', | |
| ( extensions.shaderTextureLOD || parameters.envMap ) && rendererExtensions.get( 'EXT_shader_texture_lod' ) ? '#extension GL_EXT_shader_texture_lod : enable' : '', | |
| ]; | |
| return chunks.filter( filterEmptyLine ).join( '\n' ); | |
| } | |
| function generateDefines( defines ) { | |
| var chunks = []; | |
| for ( var name in defines ) { | |
| var value = defines[ name ]; | |
| if ( value === false ) continue; | |
| chunks.push( '#define ' + name + ' ' + value ); | |
| } | |
| return chunks.join( '\n' ); | |
| } | |
| function fetchUniformLocations( gl, program, identifiers ) { | |
| var uniforms = {}; | |
| var n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS ); | |
| for ( var i = 0; i < n; i ++ ) { | |
| var info = gl.getActiveUniform( program, i ); | |
| var name = info.name; | |
| var location = gl.getUniformLocation( program, name ); | |
| //console.log("THREE.WebGLProgram: ACTIVE UNIFORM:", name); | |
| var matches = structRe.exec( name ); | |
| if ( matches ) { | |
| var structName = matches[ 1 ]; | |
| var structProperty = matches[ 2 ]; | |
| var uniformsStruct = uniforms[ structName ]; | |
| if ( ! uniformsStruct ) { | |
| uniformsStruct = uniforms[ structName ] = {}; | |
| } | |
| uniformsStruct[ structProperty ] = location; | |
| continue; | |
| } | |
| matches = arrayStructRe.exec( name ); | |
| if ( matches ) { | |
| var arrayName = matches[ 1 ]; | |
| var arrayIndex = matches[ 2 ]; | |
| var arrayProperty = matches[ 3 ]; | |
| var uniformsArray = uniforms[ arrayName ]; | |
| if ( ! uniformsArray ) { | |
| uniformsArray = uniforms[ arrayName ] = []; | |
| } | |
| var uniformsArrayIndex = uniformsArray[ arrayIndex ]; | |
| if ( ! uniformsArrayIndex ) { | |
| uniformsArrayIndex = uniformsArray[ arrayIndex ] = {}; | |
| } | |
| uniformsArrayIndex[ arrayProperty ] = location; | |
| continue; | |
| } | |
| matches = arrayRe.exec( name ); | |
| if ( matches ) { | |
| var arrayName = matches[ 1 ]; | |
| uniforms[ arrayName ] = location; | |
| continue; | |
| } | |
| uniforms[ name ] = location; | |
| } | |
| return uniforms; | |
| } | |
| function fetchAttributeLocations( gl, program, identifiers ) { | |
| var attributes = {}; | |
| var n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES ); | |
| for ( var i = 0; i < n; i ++ ) { | |
| var info = gl.getActiveAttrib( program, i ); | |
| var name = info.name; | |
| // console.log("THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:", name, i ); | |
| attributes[ name ] = gl.getAttribLocation( program, name ); | |
| } | |
| return attributes; | |
| } | |
| function filterEmptyLine( string ) { | |
| return string !== ''; | |
| } | |
| function replaceLightNums( string, parameters ) { | |
| return string | |
| .replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights ) | |
| .replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights ) | |
| .replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights ) | |
| .replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights ); | |
| } | |
| function unrollLoops( string ) { | |
| var pattern = /for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g; | |
| function replace( match, start, end, snippet ) { | |
| var unroll = ''; | |
| for ( var i = parseInt( start ); i < parseInt( end ); i ++ ) { | |
| unroll += snippet.replace( /\[ i \]/g, '[ ' + i + ' ]' ); | |
| } | |
| return unroll; | |
| } | |
| return string.replace( pattern, replace ); | |
| } | |
| return function WebGLProgram( renderer, code, material, parameters ) { | |
| var gl = renderer.context; | |
| var extensions = material.extensions; | |
| var defines = material.defines; | |
| var vertexShader = material.__webglShader.vertexShader; | |
| var fragmentShader = material.__webglShader.fragmentShader; | |
| var shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC'; | |
| if ( parameters.shadowMapType === THREE.PCFShadowMap ) { | |
| shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF'; | |
| } else if ( parameters.shadowMapType === THREE.PCFSoftShadowMap ) { | |
| shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT'; | |
| } | |
| var envMapTypeDefine = 'ENVMAP_TYPE_CUBE'; | |
| var envMapModeDefine = 'ENVMAP_MODE_REFLECTION'; | |
| var envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY'; | |
| if ( parameters.envMap ) { | |
| switch ( material.envMap.mapping ) { | |
| case THREE.CubeReflectionMapping: | |
| case THREE.CubeRefractionMapping: | |
| envMapTypeDefine = 'ENVMAP_TYPE_CUBE'; | |
| break; | |
| case THREE.EquirectangularReflectionMapping: | |
| case THREE.EquirectangularRefractionMapping: | |
| envMapTypeDefine = 'ENVMAP_TYPE_EQUIREC'; | |
| break; | |
| case THREE.SphericalReflectionMapping: | |
| envMapTypeDefine = 'ENVMAP_TYPE_SPHERE'; | |
| break; | |
| } | |
| switch ( material.envMap.mapping ) { | |
| case THREE.CubeRefractionMapping: | |
| case THREE.EquirectangularRefractionMapping: | |
| envMapModeDefine = 'ENVMAP_MODE_REFRACTION'; | |
| break; | |
| } | |
| switch ( material.combine ) { | |
| case THREE.MultiplyOperation: | |
| envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY'; | |
| break; | |
| case THREE.MixOperation: | |
| envMapBlendingDefine = 'ENVMAP_BLENDING_MIX'; | |
| break; | |
| case THREE.AddOperation: | |
| envMapBlendingDefine = 'ENVMAP_BLENDING_ADD'; | |
| break; | |
| } | |
| } | |
| var gammaFactorDefine = ( renderer.gammaFactor > 0 ) ? renderer.gammaFactor : 1.0; | |
| // console.log( 'building new program ' ); | |
| // | |
| var customExtensions = generateExtensions( extensions, parameters, renderer.extensions ); | |
| var customDefines = generateDefines( defines ); | |
| // | |
| var program = gl.createProgram(); | |
| var prefixVertex, prefixFragment; | |
| if ( material instanceof THREE.RawShaderMaterial ) { | |
| prefixVertex = ''; | |
| prefixFragment = ''; | |
| } else { | |
| prefixVertex = [ | |
| 'precision ' + parameters.precision + ' float;', | |
| 'precision ' + parameters.precision + ' int;', | |
| '#define SHADER_NAME ' + material.__webglShader.name, | |
| customDefines, | |
| parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '', | |
| renderer.gammaInput ? '#define GAMMA_INPUT' : '', | |
| renderer.gammaOutput ? '#define GAMMA_OUTPUT' : '', | |
| '#define GAMMA_FACTOR ' + gammaFactorDefine, | |
| '#define MAX_BONES ' + parameters.maxBones, | |
| parameters.map ? '#define USE_MAP' : '', | |
| parameters.envMap ? '#define USE_ENVMAP' : '', | |
| parameters.envMap ? '#define ' + envMapModeDefine : '', | |
| parameters.lightMap ? '#define USE_LIGHTMAP' : '', | |
| parameters.aoMap ? '#define USE_AOMAP' : '', | |
| parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '', | |
| parameters.bumpMap ? '#define USE_BUMPMAP' : '', | |
| parameters.normalMap ? '#define USE_NORMALMAP' : '', | |
| parameters.displacementMap && parameters.supportsVertexTextures ? '#define USE_DISPLACEMENTMAP' : '', | |
| parameters.specularMap ? '#define USE_SPECULARMAP' : '', | |
| parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '', | |
| parameters.metalnessMap ? '#define USE_METALNESSMAP' : '', | |
| parameters.alphaMap ? '#define USE_ALPHAMAP' : '', | |
| parameters.vertexColors ? '#define USE_COLOR' : '', | |
| parameters.flatShading ? '#define FLAT_SHADED' : '', | |
| parameters.skinning ? '#define USE_SKINNING' : '', | |
| parameters.useVertexTexture ? '#define BONE_TEXTURE' : '', | |
| parameters.morphTargets ? '#define USE_MORPHTARGETS' : '', | |
| parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '', | |
| parameters.doubleSided ? '#define DOUBLE_SIDED' : '', | |
| parameters.flipSided ? '#define FLIP_SIDED' : '', | |
| parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '', | |
| parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '', | |
| parameters.pointLightShadows > 0 ? '#define POINT_LIGHT_SHADOWS' : '', | |
| parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '', | |
| parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '', | |
| parameters.logarithmicDepthBuffer && renderer.extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '', | |
| 'uniform mat4 modelMatrix;', | |
| 'uniform mat4 modelViewMatrix;', | |
| 'uniform mat4 projectionMatrix;', | |
| 'uniform mat4 viewMatrix;', | |
| 'uniform mat3 normalMatrix;', | |
| 'uniform vec3 cameraPosition;', | |
| 'attribute vec3 position;', | |
| 'attribute vec3 normal;', | |
| 'attribute vec2 uv;', | |
| '#ifdef USE_COLOR', | |
| ' attribute vec3 color;', | |
| '#endif', | |
| '#ifdef USE_MORPHTARGETS', | |
| ' attribute vec3 morphTarget0;', | |
| ' attribute vec3 morphTarget1;', | |
| ' attribute vec3 morphTarget2;', | |
| ' attribute vec3 morphTarget3;', | |
| ' #ifdef USE_MORPHNORMALS', | |
| ' attribute vec3 morphNormal0;', | |
| ' attribute vec3 morphNormal1;', | |
| ' attribute vec3 morphNormal2;', | |
| ' attribute vec3 morphNormal3;', | |
| ' #else', | |
| ' attribute vec3 morphTarget4;', | |
| ' attribute vec3 morphTarget5;', | |
| ' attribute vec3 morphTarget6;', | |
| ' attribute vec3 morphTarget7;', | |
| ' #endif', | |
| '#endif', | |
| '#ifdef USE_SKINNING', | |
| ' attribute vec4 skinIndex;', | |
| ' attribute vec4 skinWeight;', | |
| '#endif', | |
| '\n' | |
| ].filter( filterEmptyLine ).join( '\n' ); | |
| prefixFragment = [ | |
| customExtensions, | |
| 'precision ' + parameters.precision + ' float;', | |
| 'precision ' + parameters.precision + ' int;', | |
| '#define SHADER_NAME ' + material.__webglShader.name, | |
| customDefines, | |
| parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '', | |
| renderer.gammaInput ? '#define GAMMA_INPUT' : '', | |
| renderer.gammaOutput ? '#define GAMMA_OUTPUT' : '', | |
| '#define GAMMA_FACTOR ' + gammaFactorDefine, | |
| ( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '', | |
| ( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '', | |
| parameters.map ? '#define USE_MAP' : '', | |
| parameters.envMap ? '#define USE_ENVMAP' : '', | |
| parameters.envMap ? '#define ' + envMapTypeDefine : '', | |
| parameters.envMap ? '#define ' + envMapModeDefine : '', | |
| parameters.envMap ? '#define ' + envMapBlendingDefine : '', | |
| parameters.lightMap ? '#define USE_LIGHTMAP' : '', | |
| parameters.aoMap ? '#define USE_AOMAP' : '', | |
| parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '', | |
| parameters.bumpMap ? '#define USE_BUMPMAP' : '', | |
| parameters.normalMap ? '#define USE_NORMALMAP' : '', | |
| parameters.specularMap ? '#define USE_SPECULARMAP' : '', | |
| parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '', | |
| parameters.metalnessMap ? '#define USE_METALNESSMAP' : '', | |
| parameters.alphaMap ? '#define USE_ALPHAMAP' : '', | |
| parameters.vertexColors ? '#define USE_COLOR' : '', | |
| parameters.flatShading ? '#define FLAT_SHADED' : '', | |
| parameters.doubleSided ? '#define DOUBLE_SIDED' : '', | |
| parameters.flipSided ? '#define FLIP_SIDED' : '', | |
| parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '', | |
| parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '', | |
| parameters.pointLightShadows > 0 ? '#define POINT_LIGHT_SHADOWS' : '', | |
| parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '', | |
| parameters.logarithmicDepthBuffer && renderer.extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '', | |
| parameters.envMap && renderer.extensions.get( 'EXT_shader_texture_lod' ) ? '#define TEXTURE_LOD_EXT' : '', | |
| 'uniform mat4 viewMatrix;', | |
| 'uniform vec3 cameraPosition;', | |
| '\n' | |
| ].filter( filterEmptyLine ).join( '\n' ); | |
| } | |
| vertexShader = replaceLightNums( vertexShader, parameters ); | |
| fragmentShader = replaceLightNums( fragmentShader, parameters ); | |
| if ( material instanceof THREE.ShaderMaterial === false ) { | |
| vertexShader = unrollLoops( vertexShader ); | |
| fragmentShader = unrollLoops( fragmentShader ); | |
| } | |
| var vertexGlsl = prefixVertex + vertexShader; | |
| var fragmentGlsl = prefixFragment + fragmentShader; | |
| // console.log( '*VERTEX*', vertexGlsl ); | |
| // console.log( '*FRAGMENT*', fragmentGlsl ); | |
| var glVertexShader = THREE.WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl ); | |
| var glFragmentShader = THREE.WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl ); | |
| gl.attachShader( program, glVertexShader ); | |
| gl.attachShader( program, glFragmentShader ); | |
| // Force a particular attribute to index 0. | |
| if ( material.index0AttributeName !== undefined ) { | |
| gl.bindAttribLocation( program, 0, material.index0AttributeName ); | |
| } else if ( parameters.morphTargets === true ) { | |
| // programs with morphTargets displace position out of attribute 0 | |
| gl.bindAttribLocation( program, 0, 'position' ); | |
| } | |
| gl.linkProgram( program ); | |
| var programLog = gl.getProgramInfoLog( program ); | |
| var vertexLog = gl.getShaderInfoLog( glVertexShader ); | |
| var fragmentLog = gl.getShaderInfoLog( glFragmentShader ); | |
| var runnable = true; | |
| var haveDiagnostics = true; | |
| // console.log( '**VERTEX**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader ) ); | |
| // console.log( '**FRAGMENT**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader ) ); | |
| if ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) { | |
| runnable = false; | |
| console.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), 'gl.VALIDATE_STATUS', gl.getProgramParameter( program, gl.VALIDATE_STATUS ), 'gl.getProgramInfoLog', programLog, vertexLog, fragmentLog ); | |
| } else if ( programLog !== '' ) { | |
| console.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog ); | |
| } else if ( vertexLog === '' || fragmentLog === '' ) { | |
| haveDiagnostics = false; | |
| } | |
| if ( haveDiagnostics ) { | |
| this.diagnostics = { | |
| runnable: runnable, | |
| material: material, | |
| programLog: programLog, | |
| vertexShader: { | |
| log: vertexLog, | |
| prefix: prefixVertex | |
| }, | |
| fragmentShader: { | |
| log: fragmentLog, | |
| prefix: prefixFragment | |
| } | |
| }; | |
| } | |
| // clean up | |
| gl.deleteShader( glVertexShader ); | |
| gl.deleteShader( glFragmentShader ); | |
| // set up caching for uniform locations | |
| var cachedUniforms; | |
| this.getUniforms = function() { | |
| if ( cachedUniforms === undefined ) { | |
| cachedUniforms = fetchUniformLocations( gl, program ); | |
| } | |
| return cachedUniforms; | |
| }; | |
| // set up caching for attribute locations | |
| var cachedAttributes; | |
| this.getAttributes = function() { | |
| if ( cachedAttributes === undefined ) { | |
| cachedAttributes = fetchAttributeLocations( gl, program ); | |
| } | |
| return cachedAttributes; | |
| }; | |
| // free resource | |
| this.destroy = function() { | |
| gl.deleteProgram( program ); | |
| this.program = undefined; | |
| }; | |
| // DEPRECATED | |
| Object.defineProperties( this, { | |
| uniforms: { | |
| get: function() { | |
| console.warn( 'THREE.WebGLProgram: .uniforms is now .getUniforms().' ); | |
| return this.getUniforms(); | |
| } | |
| }, | |
| attributes: { | |
| get: function() { | |
| console.warn( 'THREE.WebGLProgram: .attributes is now .getAttributes().' ); | |
| return this.getAttributes(); | |
| } | |
| } | |
| } ); | |
| // | |
| this.id = programIdCount ++; | |
| this.code = code; | |
| this.usedTimes = 1; | |
| this.program = program; | |
| this.vertexShader = glVertexShader; | |
| this.fragmentShader = glFragmentShader; | |
| return this; | |
| }; | |
| } )(); | |
| // File:src/renderers/webgl/WebGLPrograms.js | |
| THREE.WebGLPrograms = function ( renderer, capabilities ) { | |
| var programs = []; | |
| var shaderIDs = { | |
| MeshDepthMaterial: 'depth', | |
| MeshNormalMaterial: 'normal', | |
| MeshBasicMaterial: 'basic', | |
| MeshLambertMaterial: 'lambert', | |
| MeshPhongMaterial: 'phong', | |
| MeshStandardMaterial: 'standard', | |
| LineBasicMaterial: 'basic', | |
| LineDashedMaterial: 'dashed', | |
| PointsMaterial: 'points' | |
| }; | |
| var parameterNames = [ | |
| "precision", "supportsVertexTextures", "map", "envMap", "envMapMode", | |
| "lightMap", "aoMap", "emissiveMap", "bumpMap", "normalMap", "displacementMap", "specularMap", | |
| "roughnessMap", "metalnessMap", | |
| "alphaMap", "combine", "vertexColors", "fog", "useFog", "fogExp", | |
| "flatShading", "sizeAttenuation", "logarithmicDepthBuffer", "skinning", | |
| "maxBones", "useVertexTexture", "morphTargets", "morphNormals", | |
| "maxMorphTargets", "maxMorphNormals", | |
| "numDirLights", "numPointLights", "numSpotLights", "numHemiLights", | |
| "shadowMapEnabled", "pointLightShadows", | |
| "shadowMapType", | |
| "alphaTest", "doubleSided", "flipSided" | |
| ]; | |
| function allocateBones ( object ) { | |
| if ( capabilities.floatVertexTextures && object && object.skeleton && object.skeleton.useVertexTexture ) { | |
| return 1024; | |
| } else { | |
| // default for when object is not specified | |
| // ( for example when prebuilding shader to be used with multiple objects ) | |
| // | |
| // - leave some extra space for other uniforms | |
| // - limit here is ANGLE's 254 max uniform vectors | |
| // (up to 54 should be safe) | |
| var nVertexUniforms = capabilities.maxVertexUniforms; | |
| var nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 ); | |
| var maxBones = nVertexMatrices; | |
| if ( object !== undefined && object instanceof THREE.SkinnedMesh ) { | |
| maxBones = Math.min( object.skeleton.bones.length, maxBones ); | |
| if ( maxBones < object.skeleton.bones.length ) { | |
| console.warn( 'WebGLRenderer: too many bones - ' + object.skeleton.bones.length + ', this GPU supports just ' + maxBones + ' (try OpenGL instead of ANGLE)' ); | |
| } | |
| } | |
| return maxBones; | |
| } | |
| } | |
| this.getParameters = function ( material, lights, fog, object ) { | |
| var shaderID = shaderIDs[ material.type ]; | |
| // heuristics to create shader parameters according to lights in the scene | |
| // (not to blow over maxLights budget) | |
| var maxBones = allocateBones( object ); | |
| var precision = renderer.getPrecision(); | |
| if ( material.precision !== null ) { | |
| precision = capabilities.getMaxPrecision( material.precision ); | |
| if ( precision !== material.precision ) { | |
| console.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' ); | |
| } | |
| } | |
| var parameters = { | |
| shaderID: shaderID, | |
| precision: precision, | |
| supportsVertexTextures: capabilities.vertexTextures, | |
| map: !! material.map, | |
| envMap: !! material.envMap, | |
| envMapMode: material.envMap && material.envMap.mapping, | |
| lightMap: !! material.lightMap, | |
| aoMap: !! material.aoMap, | |
| emissiveMap: !! material.emissiveMap, | |
| bumpMap: !! material.bumpMap, | |
| normalMap: !! material.normalMap, | |
| displacementMap: !! material.displacementMap, | |
| roughnessMap: !! material.roughnessMap, | |
| metalnessMap: !! material.metalnessMap, | |
| specularMap: !! material.specularMap, | |
| alphaMap: !! material.alphaMap, | |
| combine: material.combine, | |
| vertexColors: material.vertexColors, | |
| fog: fog, | |
| useFog: material.fog, | |
| fogExp: fog instanceof THREE.FogExp2, | |
| flatShading: material.shading === THREE.FlatShading, | |
| sizeAttenuation: material.sizeAttenuation, | |
| logarithmicDepthBuffer: capabilities.logarithmicDepthBuffer, | |
| skinning: material.skinning, | |
| maxBones: maxBones, | |
| useVertexTexture: capabilities.floatVertexTextures && object && object.skeleton && object.skeleton.useVertexTexture, | |
| morphTargets: material.morphTargets, | |
| morphNormals: material.morphNormals, | |
| maxMorphTargets: renderer.maxMorphTargets, | |
| maxMorphNormals: renderer.maxMorphNormals, | |
| numDirLights: lights.directional.length, | |
| numPointLights: lights.point.length, | |
| numSpotLights: lights.spot.length, | |
| numHemiLights: lights.hemi.length, | |
| pointLightShadows: lights.shadowsPointLight, | |
| shadowMapEnabled: renderer.shadowMap.enabled && object.receiveShadow && lights.shadows.length > 0, | |
| shadowMapType: renderer.shadowMap.type, | |
| alphaTest: material.alphaTest, | |
| doubleSided: material.side === THREE.DoubleSide, | |
| flipSided: material.side === THREE.BackSide | |
| }; | |
| return parameters; | |
| }; | |
| this.getProgramCode = function ( material, parameters ) { | |
| var chunks = []; | |
| if ( parameters.shaderID ) { | |
| chunks.push( parameters.shaderID ); | |
| } else { | |
| chunks.push( material.fragmentShader ); | |
| chunks.push( material.vertexShader ); | |
| } | |
| if ( material.defines !== undefined ) { | |
| for ( var name in material.defines ) { | |
| chunks.push( name ); | |
| chunks.push( material.defines[ name ] ); | |
| } | |
| } | |
| for ( var i = 0; i < parameterNames.length; i ++ ) { | |
| var parameterName = parameterNames[ i ]; | |
| chunks.push( parameterName ); | |
| chunks.push( parameters[ parameterName ] ); | |
| } | |
| return chunks.join(); | |
| }; | |
| this.acquireProgram = function ( material, parameters, code ) { | |
| var program; | |
| // Check if code has been already compiled | |
| for ( var p = 0, pl = programs.length; p < pl; p ++ ) { | |
| var programInfo = programs[ p ]; | |
| if ( programInfo.code === code ) { | |
| program = programInfo; | |
| ++ program.usedTimes; | |
| break; | |
| } | |
| } | |
| if ( program === undefined ) { | |
| program = new THREE.WebGLProgram( renderer, code, material, parameters ); | |
| programs.push( program ); | |
| } | |
| return program; | |
| }; | |
| this.releaseProgram = function( program ) { | |
| if ( -- program.usedTimes === 0 ) { | |
| // Remove from unordered set | |
| var i = programs.indexOf( program ); | |
| programs[ i ] = programs[ programs.length - 1 ]; | |
| programs.pop(); | |
| // Free WebGL resources | |
| program.destroy(); | |
| } | |
| }; | |
| // Exposed for resource monitoring & error feedback via renderer.info: | |
| this.programs = programs; | |
| }; | |
| // File:src/renderers/webgl/WebGLProperties.js | |
| /** | |
| * @author fordacious / fordacious.github.io | |
| */ | |
| THREE.WebGLProperties = function () { | |
| var properties = {}; | |
| this.get = function ( object ) { | |
| var uuid = object.uuid; | |
| var map = properties[ uuid ]; | |
| if ( map === undefined ) { | |
| map = {}; | |
| properties[ uuid ] = map; | |
| } | |
| return map; | |
| }; | |
| this.delete = function ( object ) { | |
| delete properties[ object.uuid ]; | |
| }; | |
| this.clear = function () { | |
| properties = {}; | |
| }; | |
| }; | |
| // File:src/renderers/webgl/WebGLShader.js | |
| THREE.WebGLShader = ( function () { | |
| function addLineNumbers( string ) { | |
| var lines = string.split( '\n' ); | |
| for ( var i = 0; i < lines.length; i ++ ) { | |
| lines[ i ] = ( i + 1 ) + ': ' + lines[ i ]; | |
| } | |
| return lines.join( '\n' ); | |
| } | |
| return function WebGLShader( gl, type, string ) { | |
| var shader = gl.createShader( type ); | |
| gl.shaderSource( shader, string ); | |
| gl.compileShader( shader ); | |
| if ( gl.getShaderParameter( shader, gl.COMPILE_STATUS ) === false ) { | |
| console.error( 'THREE.WebGLShader: Shader couldn\'t compile.' ); | |
| } | |
| if ( gl.getShaderInfoLog( shader ) !== '' ) { | |
| console.warn( 'THREE.WebGLShader: gl.getShaderInfoLog()', type === gl.VERTEX_SHADER ? 'vertex' : 'fragment', gl.getShaderInfoLog( shader ), addLineNumbers( string ) ); | |
| } | |
| // --enable-privileged-webgl-extension | |
| // console.log( type, gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) ); | |
| return shader; | |
| }; | |
| } )(); | |
| // File:src/renderers/webgl/WebGLShadowMap.js | |
| /** | |
| * @author alteredq / http://alteredqualia.com/ | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLShadowMap = function ( _renderer, _lights, _objects ) { | |
| var _gl = _renderer.context, | |
| _state = _renderer.state, | |
| _frustum = new THREE.Frustum(), | |
| _projScreenMatrix = new THREE.Matrix4(), | |
| _lookTarget = new THREE.Vector3(), | |
| _lightPositionWorld = new THREE.Vector3(), | |
| _renderList = [], | |
| _MorphingFlag = 1, | |
| _SkinningFlag = 2, | |
| _NumberOfMaterialVariants = ( _MorphingFlag | _SkinningFlag ) + 1, | |
| _depthMaterials = new Array( _NumberOfMaterialVariants ), | |
| _distanceMaterials = new Array( _NumberOfMaterialVariants ); | |
| var cubeDirections = [ | |
| new THREE.Vector3( 1, 0, 0 ), new THREE.Vector3( - 1, 0, 0 ), new THREE.Vector3( 0, 0, 1 ), | |
| new THREE.Vector3( 0, 0, - 1 ), new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, - 1, 0 ) | |
| ]; | |
| var cubeUps = [ | |
| new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 1, 0 ), | |
| new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 0, 1 ), new THREE.Vector3( 0, 0, - 1 ) | |
| ]; | |
| var cube2DViewPorts = [ | |
| new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4(), | |
| new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4() | |
| ]; | |
| // init | |
| var depthShader = THREE.ShaderLib[ "depthRGBA" ]; | |
| var depthUniforms = THREE.UniformsUtils.clone( depthShader.uniforms ); | |
| var distanceShader = THREE.ShaderLib[ "distanceRGBA" ]; | |
| var distanceUniforms = THREE.UniformsUtils.clone( distanceShader.uniforms ); | |
| for ( var i = 0; i !== _NumberOfMaterialVariants; ++ i ) { | |
| var useMorphing = ( i & _MorphingFlag ) !== 0; | |
| var useSkinning = ( i & _SkinningFlag ) !== 0; | |
| var depthMaterial = new THREE.ShaderMaterial( { | |
| uniforms: depthUniforms, | |
| vertexShader: depthShader.vertexShader, | |
| fragmentShader: depthShader.fragmentShader, | |
| morphTargets: useMorphing, | |
| skinning: useSkinning | |
| } ); | |
| depthMaterial._shadowPass = true; | |
| _depthMaterials[ i ] = depthMaterial; | |
| var distanceMaterial = new THREE.ShaderMaterial( { | |
| uniforms: distanceUniforms, | |
| vertexShader: distanceShader.vertexShader, | |
| fragmentShader: distanceShader.fragmentShader, | |
| morphTargets: useMorphing, | |
| skinning: useSkinning | |
| } ); | |
| distanceMaterial._shadowPass = true; | |
| _distanceMaterials[ i ] = distanceMaterial; | |
| } | |
| // | |
| var scope = this; | |
| this.enabled = false; | |
| this.autoUpdate = true; | |
| this.needsUpdate = false; | |
| this.type = THREE.PCFShadowMap; | |
| this.cullFace = THREE.CullFaceFront; | |
| this.render = function ( scene, camera ) { | |
| var faceCount, isPointLight; | |
| if ( scope.enabled === false ) return; | |
| if ( scope.autoUpdate === false && scope.needsUpdate === false ) return; | |
| // Set GL state for depth map. | |
| _state.clearColor( 1, 1, 1, 1 ); | |
| _state.disable( _gl.BLEND ); | |
| _state.enable( _gl.CULL_FACE ); | |
| _gl.frontFace( _gl.CCW ); | |
| _gl.cullFace( scope.cullFace === THREE.CullFaceFront ? _gl.FRONT : _gl.BACK ); | |
| _state.setDepthTest( true ); | |
| _state.setScissorTest( false ); | |
| // render depth map | |
| var shadows = _lights.shadows; | |
| for ( var i = 0, il = shadows.length; i < il; i ++ ) { | |
| var light = shadows[ i ]; | |
| var shadow = light.shadow; | |
| var shadowCamera = shadow.camera; | |
| var shadowMapSize = shadow.mapSize; | |
| if ( light instanceof THREE.PointLight ) { | |
| faceCount = 6; | |
| isPointLight = true; | |
| var vpWidth = shadowMapSize.x / 4.0; | |
| var vpHeight = shadowMapSize.y / 2.0; | |
| // These viewports map a cube-map onto a 2D texture with the | |
| // following orientation: | |
| // | |
| // xzXZ | |
| // y Y | |
| // | |
| // X - Positive x direction | |
| // x - Negative x direction | |
| // Y - Positive y direction | |
| // y - Negative y direction | |
| // Z - Positive z direction | |
| // z - Negative z direction | |
| // positive X | |
| cube2DViewPorts[ 0 ].set( vpWidth * 2, vpHeight, vpWidth, vpHeight ); | |
| // negative X | |
| cube2DViewPorts[ 1 ].set( 0, vpHeight, vpWidth, vpHeight ); | |
| // positive Z | |
| cube2DViewPorts[ 2 ].set( vpWidth * 3, vpHeight, vpWidth, vpHeight ); | |
| // negative Z | |
| cube2DViewPorts[ 3 ].set( vpWidth, vpHeight, vpWidth, vpHeight ); | |
| // positive Y | |
| cube2DViewPorts[ 4 ].set( vpWidth * 3, 0, vpWidth, vpHeight ); | |
| // negative Y | |
| cube2DViewPorts[ 5 ].set( vpWidth, 0, vpWidth, vpHeight ); | |
| } else { | |
| faceCount = 1; | |
| isPointLight = false; | |
| } | |
| if ( shadow.map === null ) { | |
| var pars = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBAFormat }; | |
| shadow.map = new THREE.WebGLRenderTarget( shadowMapSize.x, shadowMapSize.y, pars ); | |
| // | |
| if ( light instanceof THREE.SpotLight ) { | |
| shadowCamera.aspect = shadowMapSize.x / shadowMapSize.y; | |
| } | |
| shadowCamera.updateProjectionMatrix(); | |
| } | |
| var shadowMap = shadow.map; | |
| var shadowMatrix = shadow.matrix; | |
| _lightPositionWorld.setFromMatrixPosition( light.matrixWorld ); | |
| shadowCamera.position.copy( _lightPositionWorld ); | |
| _renderer.setRenderTarget( shadowMap ); | |
| _renderer.clear(); | |
| // render shadow map for each cube face (if omni-directional) or | |
| // run a single pass if not | |
| for ( var face = 0; face < faceCount; face ++ ) { | |
| if ( isPointLight ) { | |
| _lookTarget.copy( shadowCamera.position ); | |
| _lookTarget.add( cubeDirections[ face ] ); | |
| shadowCamera.up.copy( cubeUps[ face ] ); | |
| shadowCamera.lookAt( _lookTarget ); | |
| var vpDimensions = cube2DViewPorts[ face ]; | |
| _state.viewport( vpDimensions ); | |
| } else { | |
| _lookTarget.setFromMatrixPosition( light.target.matrixWorld ); | |
| shadowCamera.lookAt( _lookTarget ); | |
| } | |
| shadowCamera.updateMatrixWorld(); | |
| shadowCamera.matrixWorldInverse.getInverse( shadowCamera.matrixWorld ); | |
| // compute shadow matrix | |
| shadowMatrix.set( | |
| 0.5, 0.0, 0.0, 0.5, | |
| 0.0, 0.5, 0.0, 0.5, | |
| 0.0, 0.0, 0.5, 0.5, | |
| 0.0, 0.0, 0.0, 1.0 | |
| ); | |
| shadowMatrix.multiply( shadowCamera.projectionMatrix ); | |
| shadowMatrix.multiply( shadowCamera.matrixWorldInverse ); | |
| // update camera matrices and frustum | |
| _projScreenMatrix.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse ); | |
| _frustum.setFromMatrix( _projScreenMatrix ); | |
| // set object matrices & frustum culling | |
| _renderList.length = 0; | |
| projectObject( scene, camera, shadowCamera ); | |
| // render shadow map | |
| // render regular objects | |
| for ( var j = 0, jl = _renderList.length; j < jl; j ++ ) { | |
| var object = _renderList[ j ]; | |
| var geometry = _objects.update( object ); | |
| var material = object.material; | |
| if ( material instanceof THREE.MultiMaterial ) { | |
| var groups = geometry.groups; | |
| var materials = material.materials; | |
| for ( var k = 0, kl = groups.length; k < kl; k ++ ) { | |
| var group = groups[ k ]; | |
| var groupMaterial = materials[ group.materialIndex ]; | |
| if ( groupMaterial.visible === true ) { | |
| var depthMaterial = getDepthMaterial( object, groupMaterial, isPointLight, _lightPositionWorld ); | |
| _renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group ); | |
| } | |
| } | |
| } else { | |
| var depthMaterial = getDepthMaterial( object, material, isPointLight, _lightPositionWorld ); | |
| _renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null ); | |
| } | |
| } | |
| } | |
| // We must call _renderer.resetGLState() at the end of each iteration of | |
| // the light loop in order to force material updates for each light. | |
| _renderer.resetGLState(); | |
| } | |
| // Restore GL state. | |
| var clearColor = _renderer.getClearColor(), | |
| clearAlpha = _renderer.getClearAlpha(); | |
| _renderer.setClearColor( clearColor, clearAlpha ); | |
| _state.enable( _gl.BLEND ); | |
| if ( scope.cullFace === THREE.CullFaceFront ) { | |
| _gl.cullFace( _gl.BACK ); | |
| } | |
| _renderer.resetGLState(); | |
| scope.needsUpdate = false; | |
| }; | |
| function getDepthMaterial( object, material, isPointLight, lightPositionWorld ) { | |
| var geometry = object.geometry; | |
| var newMaterial = null; | |
| var materialVariants = _depthMaterials; | |
| var customMaterial = object.customDepthMaterial; | |
| if ( isPointLight ) { | |
| materialVariants = _distanceMaterials; | |
| customMaterial = object.customDistanceMaterial; | |
| } | |
| if ( ! customMaterial ) { | |
| var useMorphing = geometry.morphTargets !== undefined && | |
| geometry.morphTargets.length > 0 && material.morphTargets; | |
| var useSkinning = object instanceof THREE.SkinnedMesh && material.skinning; | |
| var variantIndex = 0; | |
| if ( useMorphing ) variantIndex |= _MorphingFlag; | |
| if ( useSkinning ) variantIndex |= _SkinningFlag; | |
| newMaterial = materialVariants[ variantIndex ]; | |
| } else { | |
| newMaterial = customMaterial; | |
| } | |
| newMaterial.visible = material.visible; | |
| newMaterial.wireframe = material.wireframe; | |
| newMaterial.wireframeLinewidth = material.wireframeLinewidth; | |
| if ( isPointLight && newMaterial.uniforms.lightPos !== undefined ) { | |
| newMaterial.uniforms.lightPos.value.copy( lightPositionWorld ); | |
| } | |
| return newMaterial; | |
| } | |
| function projectObject( object, camera, shadowCamera ) { | |
| if ( object.visible === false ) return; | |
| if ( object.layers.test( camera.layers ) && ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points ) ) { | |
| if ( object.castShadow && ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) ) { | |
| var material = object.material; | |
| if ( material.visible === true ) { | |
| object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld ); | |
| _renderList.push( object ); | |
| } | |
| } | |
| } | |
| var children = object.children; | |
| for ( var i = 0, l = children.length; i < l; i ++ ) { | |
| projectObject( children[ i ], camera, shadowCamera ); | |
| } | |
| } | |
| }; | |
| // File:src/renderers/webgl/WebGLState.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| THREE.WebGLState = function ( gl, extensions, paramThreeToGL ) { | |
| var _this = this; | |
| var color = new THREE.Vector4(); | |
| var newAttributes = new Uint8Array( 16 ); | |
| var enabledAttributes = new Uint8Array( 16 ); | |
| var attributeDivisors = new Uint8Array( 16 ); | |
| var capabilities = {}; | |
| var compressedTextureFormats = null; | |
| var currentBlending = null; | |
| var currentBlendEquation = null; | |
| var currentBlendSrc = null; | |
| var currentBlendDst = null; | |
| var currentBlendEquationAlpha = null; | |
| var currentBlendSrcAlpha = null; | |
| var currentBlendDstAlpha = null; | |
| var currentDepthFunc = null; | |
| var currentDepthWrite = null; | |
| var currentColorWrite = null; | |
| var currentStencilWrite = null; | |
| var currentStencilFunc = null; | |
| var currentStencilRef = null; | |
| var currentStencilMask = null; | |
| var currentStencilFail = null; | |
| var currentStencilZFail = null; | |
| var currentStencilZPass = null; | |
| var currentFlipSided = null; | |
| var currentLineWidth = null; | |
| var currentPolygonOffsetFactor = null; | |
| var currentPolygonOffsetUnits = null; | |
| var currentScissorTest = null; | |
| var maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS ); | |
| var currentTextureSlot = undefined; | |
| var currentBoundTextures = {}; | |
| var currentClearColor = new THREE.Vector4(); | |
| var currentClearDepth = null; | |
| var currentClearStencil = null; | |
| var currentScissor = new THREE.Vector4(); | |
| var currentViewport = new THREE.Vector4(); | |
| this.init = function () { | |
| this.clearColor( 0, 0, 0, 1 ); | |
| this.clearDepth( 1 ); | |
| this.clearStencil( 0 ); | |
| this.enable( gl.DEPTH_TEST ); | |
| gl.depthFunc( gl.LEQUAL ); | |
| gl.frontFace( gl.CCW ); | |
| gl.cullFace( gl.BACK ); | |
| this.enable( gl.CULL_FACE ); | |
| this.enable( gl.BLEND ); | |
| gl.blendEquation( gl.FUNC_ADD ); | |
| gl.blendFunc( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA ); | |
| }; | |
| this.initAttributes = function () { | |
| for ( var i = 0, l = newAttributes.length; i < l; i ++ ) { | |
| newAttributes[ i ] = 0; | |
| } | |
| }; | |
| this.enableAttribute = function ( attribute ) { | |
| newAttributes[ attribute ] = 1; | |
| if ( enabledAttributes[ attribute ] === 0 ) { | |
| gl.enableVertexAttribArray( attribute ); | |
| enabledAttributes[ attribute ] = 1; | |
| } | |
| if ( attributeDivisors[ attribute ] !== 0 ) { | |
| var extension = extensions.get( 'ANGLE_instanced_arrays' ); | |
| extension.vertexAttribDivisorANGLE( attribute, 0 ); | |
| attributeDivisors[ attribute ] = 0; | |
| } | |
| }; | |
| this.enableAttributeAndDivisor = function ( attribute, meshPerAttribute, extension ) { | |
| newAttributes[ attribute ] = 1; | |
| if ( enabledAttributes[ attribute ] === 0 ) { | |
| gl.enableVertexAttribArray( attribute ); | |
| enabledAttributes[ attribute ] = 1; | |
| } | |
| if ( attributeDivisors[ attribute ] !== meshPerAttribute ) { | |
| extension.vertexAttribDivisorANGLE( attribute, meshPerAttribute ); | |
| attributeDivisors[ attribute ] = meshPerAttribute; | |
| } | |
| }; | |
| this.disableUnusedAttributes = function () { | |
| for ( var i = 0, l = enabledAttributes.length; i < l; i ++ ) { | |
| if ( enabledAttributes[ i ] !== newAttributes[ i ] ) { | |
| gl.disableVertexAttribArray( i ); | |
| enabledAttributes[ i ] = 0; | |
| } | |
| } | |
| }; | |
| this.enable = function ( id ) { | |
| if ( capabilities[ id ] !== true ) { | |
| gl.enable( id ); | |
| capabilities[ id ] = true; | |
| } | |
| }; | |
| this.disable = function ( id ) { | |
| if ( capabilities[ id ] !== false ) { | |
| gl.disable( id ); | |
| capabilities[ id ] = false; | |
| } | |
| }; | |
| this.getCompressedTextureFormats = function () { | |
| if ( compressedTextureFormats === null ) { | |
| compressedTextureFormats = []; | |
| if ( extensions.get( 'WEBGL_compressed_texture_pvrtc' ) || | |
| extensions.get( 'WEBGL_compressed_texture_s3tc' ) || | |
| extensions.get( 'WEBGL_compressed_texture_etc1' )) { | |
| var formats = gl.getParameter( gl.COMPRESSED_TEXTURE_FORMATS ); | |
| for ( var i = 0; i < formats.length; i ++ ) { | |
| compressedTextureFormats.push( formats[ i ] ); | |
| } | |
| } | |
| } | |
| return compressedTextureFormats; | |
| }; | |
| this.setBlending = function ( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha ) { | |
| if ( blending === THREE.NoBlending ) { | |
| this.disable( gl.BLEND ); | |
| } else { | |
| this.enable( gl.BLEND ); | |
| } | |
| if ( blending !== currentBlending ) { | |
| if ( blending === THREE.AdditiveBlending ) { | |
| gl.blendEquation( gl.FUNC_ADD ); | |
| gl.blendFunc( gl.SRC_ALPHA, gl.ONE ); | |
| } else if ( blending === THREE.SubtractiveBlending ) { | |
| // TODO: Find blendFuncSeparate() combination | |
| gl.blendEquation( gl.FUNC_ADD ); | |
| gl.blendFunc( gl.ZERO, gl.ONE_MINUS_SRC_COLOR ); | |
| } else if ( blending === THREE.MultiplyBlending ) { | |
| // TODO: Find blendFuncSeparate() combination | |
| gl.blendEquation( gl.FUNC_ADD ); | |
| gl.blendFunc( gl.ZERO, gl.SRC_COLOR ); | |
| } else { | |
| gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD ); | |
| gl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA ); | |
| } | |
| currentBlending = blending; | |
| } | |
| if ( blending === THREE.CustomBlending ) { | |
| blendEquationAlpha = blendEquationAlpha || blendEquation; | |
| blendSrcAlpha = blendSrcAlpha || blendSrc; | |
| blendDstAlpha = blendDstAlpha || blendDst; | |
| if ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) { | |
| gl.blendEquationSeparate( paramThreeToGL( blendEquation ), paramThreeToGL( blendEquationAlpha ) ); | |
| currentBlendEquation = blendEquation; | |
| currentBlendEquationAlpha = blendEquationAlpha; | |
| } | |
| if ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) { | |
| gl.blendFuncSeparate( paramThreeToGL( blendSrc ), paramThreeToGL( blendDst ), paramThreeToGL( blendSrcAlpha ), paramThreeToGL( blendDstAlpha ) ); | |
| currentBlendSrc = blendSrc; | |
| currentBlendDst = blendDst; | |
| currentBlendSrcAlpha = blendSrcAlpha; | |
| currentBlendDstAlpha = blendDstAlpha; | |
| } | |
| } else { | |
| currentBlendEquation = null; | |
| currentBlendSrc = null; | |
| currentBlendDst = null; | |
| currentBlendEquationAlpha = null; | |
| currentBlendSrcAlpha = null; | |
| currentBlendDstAlpha = null; | |
| } | |
| }; | |
| this.setDepthFunc = function ( depthFunc ) { | |
| if ( currentDepthFunc !== depthFunc ) { | |
| if ( depthFunc ) { | |
| switch ( depthFunc ) { | |
| case THREE.NeverDepth: | |
| gl.depthFunc( gl.NEVER ); | |
| break; | |
| case THREE.AlwaysDepth: | |
| gl.depthFunc( gl.ALWAYS ); | |
| break; | |
| case THREE.LessDepth: | |
| gl.depthFunc( gl.LESS ); | |
| break; | |
| case THREE.LessEqualDepth: | |
| gl.depthFunc( gl.LEQUAL ); | |
| break; | |
| case THREE.EqualDepth: | |
| gl.depthFunc( gl.EQUAL ); | |
| break; | |
| case THREE.GreaterEqualDepth: | |
| gl.depthFunc( gl.GEQUAL ); | |
| break; | |
| case THREE.GreaterDepth: | |
| gl.depthFunc( gl.GREATER ); | |
| break; | |
| case THREE.NotEqualDepth: | |
| gl.depthFunc( gl.NOTEQUAL ); | |
| break; | |
| default: | |
| gl.depthFunc( gl.LEQUAL ); | |
| } | |
| } else { | |
| gl.depthFunc( gl.LEQUAL ); | |
| } | |
| currentDepthFunc = depthFunc; | |
| } | |
| }; | |
| this.setDepthTest = function ( depthTest ) { | |
| if ( depthTest ) { | |
| this.enable( gl.DEPTH_TEST ); | |
| } else { | |
| this.disable( gl.DEPTH_TEST ); | |
| } | |
| }; | |
| this.setDepthWrite = function ( depthWrite ) { | |
| // TODO: Rename to setDepthMask | |
| if ( currentDepthWrite !== depthWrite ) { | |
| gl.depthMask( depthWrite ); | |
| currentDepthWrite = depthWrite; | |
| } | |
| }; | |
| this.setColorWrite = function ( colorWrite ) { | |
| // TODO: Rename to setColorMask | |
| if ( currentColorWrite !== colorWrite ) { | |
| gl.colorMask( colorWrite, colorWrite, colorWrite, colorWrite ); | |
| currentColorWrite = colorWrite; | |
| } | |
| }; | |
| this.setStencilFunc = function ( stencilFunc, stencilRef, stencilMask ) { | |
| if ( currentStencilFunc !== stencilFunc || | |
| currentStencilRef !== stencilRef || | |
| currentStencilMask !== stencilMask ) { | |
| gl.stencilFunc( stencilFunc, stencilRef, stencilMask ); | |
| currentStencilFunc = stencilFunc; | |
| currentStencilRef = stencilRef; | |
| currentStencilMask = stencilMask; | |
| } | |
| }; | |
| this.setStencilOp = function ( stencilFail, stencilZFail, stencilZPass ) { | |
| if ( currentStencilFail !== stencilFail || | |
| currentStencilZFail !== stencilZFail || | |
| currentStencilZPass !== stencilZPass ) { | |
| gl.stencilOp( stencilFail, stencilZFail, stencilZPass ); | |
| currentStencilFail = stencilFail; | |
| currentStencilZFail = stencilZFail; | |
| currentStencilZPass = stencilZPass; | |
| } | |
| }; | |
| this.setStencilTest = function ( stencilTest ) { | |
| if ( stencilTest ) { | |
| this.enable( gl.STENCIL_TEST ); | |
| } else { | |
| this.disable( gl.STENCIL_TEST ); | |
| } | |
| }; | |
| this.setStencilWrite = function ( stencilWrite ) { | |
| // TODO: Rename to setStencilMask | |
| if ( currentStencilWrite !== stencilWrite ) { | |
| gl.stencilMask( stencilWrite ); | |
| currentStencilWrite = stencilWrite; | |
| } | |
| }; | |
| this.setFlipSided = function ( flipSided ) { | |
| if ( currentFlipSided !== flipSided ) { | |
| if ( flipSided ) { | |
| gl.frontFace( gl.CW ); | |
| } else { | |
| gl.frontFace( gl.CCW ); | |
| } | |
| currentFlipSided = flipSided; | |
| } | |
| }; | |
| this.setLineWidth = function ( width ) { | |
| if ( width !== currentLineWidth ) { | |
| gl.lineWidth( width ); | |
| currentLineWidth = width; | |
| } | |
| }; | |
| this.setPolygonOffset = function ( polygonOffset, factor, units ) { | |
| if ( polygonOffset ) { | |
| this.enable( gl.POLYGON_OFFSET_FILL ); | |
| } else { | |
| this.disable( gl.POLYGON_OFFSET_FILL ); | |
| } | |
| if ( polygonOffset && ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) ) { | |
| gl.polygonOffset( factor, units ); | |
| currentPolygonOffsetFactor = factor; | |
| currentPolygonOffsetUnits = units; | |
| } | |
| }; | |
| this.getScissorTest = function () { | |
| return currentScissorTest; | |
| }; | |
| this.setScissorTest = function ( scissorTest ) { | |
| currentScissorTest = scissorTest; | |
| if ( scissorTest ) { | |
| this.enable( gl.SCISSOR_TEST ); | |
| } else { | |
| this.disable( gl.SCISSOR_TEST ); | |
| } | |
| }; | |
| // texture | |
| this.activeTexture = function ( webglSlot ) { | |
| if ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1; | |
| if ( currentTextureSlot !== webglSlot ) { | |
| gl.activeTexture( webglSlot ); | |
| currentTextureSlot = webglSlot; | |
| } | |
| }; | |
| this.bindTexture = function ( webglType, webglTexture ) { | |
| if ( currentTextureSlot === undefined ) { | |
| _this.activeTexture(); | |
| } | |
| var boundTexture = currentBoundTextures[ currentTextureSlot ]; | |
| if ( boundTexture === undefined ) { | |
| boundTexture = { type: undefined, texture: undefined }; | |
| currentBoundTextures[ currentTextureSlot ] = boundTexture; | |
| } | |
| if ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) { | |
| gl.bindTexture( webglType, webglTexture ); | |
| boundTexture.type = webglType; | |
| boundTexture.texture = webglTexture; | |
| } | |
| }; | |
| this.compressedTexImage2D = function () { | |
| try { | |
| gl.compressedTexImage2D.apply( gl, arguments ); | |
| } catch ( error ) { | |
| console.error( error ); | |
| } | |
| }; | |
| this.texImage2D = function () { | |
| try { | |
| gl.texImage2D.apply( gl, arguments ); | |
| } catch ( error ) { | |
| console.error( error ); | |
| } | |
| }; | |
| // clear values | |
| this.clearColor = function ( r, g, b, a ) { | |
| color.set( r, g, b, a ); | |
| if ( currentClearColor.equals( color ) === false ) { | |
| gl.clearColor( r, g, b, a ); | |
| currentClearColor.copy( color ); | |
| } | |
| }; | |
| this.clearDepth = function ( depth ) { | |
| if ( currentClearDepth !== depth ) { | |
| gl.clearDepth( depth ); | |
| currentClearDepth = depth; | |
| } | |
| }; | |
| this.clearStencil = function ( stencil ) { | |
| if ( currentClearStencil !== stencil ) { | |
| gl.clearStencil( stencil ); | |
| currentClearStencil = stencil; | |
| } | |
| }; | |
| // | |
| this.scissor = function ( scissor ) { | |
| if ( currentScissor.equals( scissor ) === false ) { | |
| gl.scissor( scissor.x, scissor.y, scissor.z, scissor.w ); | |
| currentScissor.copy( scissor ); | |
| } | |
| }; | |
| this.viewport = function ( viewport ) { | |
| if ( currentViewport.equals( viewport ) === false ) { | |
| gl.viewport( viewport.x, viewport.y, viewport.z, viewport.w ); | |
| currentViewport.copy( viewport ); | |
| } | |
| }; | |
| // | |
| this.reset = function () { | |
| for ( var i = 0; i < enabledAttributes.length; i ++ ) { | |
| if ( enabledAttributes[ i ] === 1 ) { | |
| gl.disableVertexAttribArray( i ); | |
| enabledAttributes[ i ] = 0; | |
| } | |
| } | |
| capabilities = {}; | |
| compressedTextureFormats = null; | |
| currentBlending = null; | |
| currentColorWrite = null; | |
| currentDepthWrite = null; | |
| currentStencilWrite = null; | |
| currentFlipSided = null; | |
| }; | |
| }; | |
| // File:src/renderers/webgl/plugins/LensFlarePlugin.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.LensFlarePlugin = function ( renderer, flares ) { | |
| var gl = renderer.context; | |
| var state = renderer.state; | |
| var vertexBuffer, elementBuffer; | |
| var program, attributes, uniforms; | |
| var hasVertexTexture; | |
| var tempTexture, occlusionTexture; | |
| function init() { | |
| var vertices = new Float32Array( [ | |
| - 1, - 1, 0, 0, | |
| 1, - 1, 1, 0, | |
| 1, 1, 1, 1, | |
| - 1, 1, 0, 1 | |
| ] ); | |
| var faces = new Uint16Array( [ | |
| 0, 1, 2, | |
| 0, 2, 3 | |
| ] ); | |
| // buffers | |
| vertexBuffer = gl.createBuffer(); | |
| elementBuffer = gl.createBuffer(); | |
| gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); | |
| gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW ); | |
| gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); | |
| gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW ); | |
| // textures | |
| tempTexture = gl.createTexture(); | |
| occlusionTexture = gl.createTexture(); | |
| state.bindTexture( gl.TEXTURE_2D, tempTexture ); | |
| gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, 16, 16, 0, gl.RGB, gl.UNSIGNED_BYTE, null ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST ); | |
| state.bindTexture( gl.TEXTURE_2D, occlusionTexture ); | |
| gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_BYTE, null ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST ); | |
| gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST ); | |
| hasVertexTexture = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS ) > 0; | |
| var shader; | |
| if ( hasVertexTexture ) { | |
| shader = { | |
| vertexShader: [ | |
| "uniform lowp int renderType;", | |
| "uniform vec3 screenPosition;", | |
| "uniform vec2 scale;", | |
| "uniform float rotation;", | |
| "uniform sampler2D occlusionMap;", | |
| "attribute vec2 position;", | |
| "attribute vec2 uv;", | |
| "varying vec2 vUV;", | |
| "varying float vVisibility;", | |
| "void main() {", | |
| "vUV = uv;", | |
| "vec2 pos = position;", | |
| "if ( renderType == 2 ) {", | |
| "vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );", | |
| "visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );", | |
| "vVisibility = visibility.r / 9.0;", | |
| "vVisibility *= 1.0 - visibility.g / 9.0;", | |
| "vVisibility *= visibility.b / 9.0;", | |
| "vVisibility *= 1.0 - visibility.a / 9.0;", | |
| "pos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;", | |
| "pos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;", | |
| "}", | |
| "gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );", | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "uniform lowp int renderType;", | |
| "uniform sampler2D map;", | |
| "uniform float opacity;", | |
| "uniform vec3 color;", | |
| "varying vec2 vUV;", | |
| "varying float vVisibility;", | |
| "void main() {", | |
| // pink square | |
| "if ( renderType == 0 ) {", | |
| "gl_FragColor = vec4( 1.0, 0.0, 1.0, 0.0 );", | |
| // restore | |
| "} else if ( renderType == 1 ) {", | |
| "gl_FragColor = texture2D( map, vUV );", | |
| // flare | |
| "} else {", | |
| "vec4 texture = texture2D( map, vUV );", | |
| "texture.a *= opacity * vVisibility;", | |
| "gl_FragColor = texture;", | |
| "gl_FragColor.rgb *= color;", | |
| "}", | |
| "}" | |
| ].join( "\n" ) | |
| }; | |
| } else { | |
| shader = { | |
| vertexShader: [ | |
| "uniform lowp int renderType;", | |
| "uniform vec3 screenPosition;", | |
| "uniform vec2 scale;", | |
| "uniform float rotation;", | |
| "attribute vec2 position;", | |
| "attribute vec2 uv;", | |
| "varying vec2 vUV;", | |
| "void main() {", | |
| "vUV = uv;", | |
| "vec2 pos = position;", | |
| "if ( renderType == 2 ) {", | |
| "pos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;", | |
| "pos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;", | |
| "}", | |
| "gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );", | |
| "}" | |
| ].join( "\n" ), | |
| fragmentShader: [ | |
| "precision mediump float;", | |
| "uniform lowp int renderType;", | |
| "uniform sampler2D map;", | |
| "uniform sampler2D occlusionMap;", | |
| "uniform float opacity;", | |
| "uniform vec3 color;", | |
| "varying vec2 vUV;", | |
| "void main() {", | |
| // pink square | |
| "if ( renderType == 0 ) {", | |
| "gl_FragColor = vec4( texture2D( map, vUV ).rgb, 0.0 );", | |
| // restore | |
| "} else if ( renderType == 1 ) {", | |
| "gl_FragColor = texture2D( map, vUV );", | |
| // flare | |
| "} else {", | |
| "float visibility = texture2D( occlusionMap, vec2( 0.5, 0.1 ) ).a;", | |
| "visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) ).a;", | |
| "visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) ).a;", | |
| "visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) ).a;", | |
| "visibility = ( 1.0 - visibility / 4.0 );", | |
| "vec4 texture = texture2D( map, vUV );", | |
| "texture.a *= opacity * visibility;", | |
| "gl_FragColor = texture;", | |
| "gl_FragColor.rgb *= color;", | |
| "}", | |
| "}" | |
| ].join( "\n" ) | |
| }; | |
| } | |
| program = createProgram( shader ); | |
| attributes = { | |
| vertex: gl.getAttribLocation ( program, "position" ), | |
| uv: gl.getAttribLocation ( program, "uv" ) | |
| }; | |
| uniforms = { | |
| renderType: gl.getUniformLocation( program, "renderType" ), | |
| map: gl.getUniformLocation( program, "map" ), | |
| occlusionMap: gl.getUniformLocation( program, "occlusionMap" ), | |
| opacity: gl.getUniformLocation( program, "opacity" ), | |
| color: gl.getUniformLocation( program, "color" ), | |
| scale: gl.getUniformLocation( program, "scale" ), | |
| rotation: gl.getUniformLocation( program, "rotation" ), | |
| screenPosition: gl.getUniformLocation( program, "screenPosition" ) | |
| }; | |
| } | |
| /* | |
| * Render lens flares | |
| * Method: renders 16x16 0xff00ff-colored points scattered over the light source area, | |
| * reads these back and calculates occlusion. | |
| */ | |
| this.render = function ( scene, camera, viewport ) { | |
| if ( flares.length === 0 ) return; | |
| var tempPosition = new THREE.Vector3(); | |
| var invAspect = viewport.w / viewport.z, | |
| halfViewportWidth = viewport.z * 0.5, | |
| halfViewportHeight = viewport.w * 0.5; | |
| var size = 16 / viewport.w, | |
| scale = new THREE.Vector2( size * invAspect, size ); | |
| var screenPosition = new THREE.Vector3( 1, 1, 0 ), | |
| screenPositionPixels = new THREE.Vector2( 1, 1 ); | |
| if ( program === undefined ) { | |
| init(); | |
| } | |
| gl.useProgram( program ); | |
| state.initAttributes(); | |
| state.enableAttribute( attributes.vertex ); | |
| state.enableAttribute( attributes.uv ); | |
| state.disableUnusedAttributes(); | |
| // loop through all lens flares to update their occlusion and positions | |
| // setup gl and common used attribs/uniforms | |
| gl.uniform1i( uniforms.occlusionMap, 0 ); | |
| gl.uniform1i( uniforms.map, 1 ); | |
| gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); | |
| gl.vertexAttribPointer( attributes.vertex, 2, gl.FLOAT, false, 2 * 8, 0 ); | |
| gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 ); | |
| gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); | |
| state.disable( gl.CULL_FACE ); | |
| state.setDepthWrite( false ); | |
| for ( var i = 0, l = flares.length; i < l; i ++ ) { | |
| size = 16 / viewport.w; | |
| scale.set( size * invAspect, size ); | |
| // calc object screen position | |
| var flare = flares[ i ]; | |
| tempPosition.set( flare.matrixWorld.elements[ 12 ], flare.matrixWorld.elements[ 13 ], flare.matrixWorld.elements[ 14 ] ); | |
| tempPosition.applyMatrix4( camera.matrixWorldInverse ); | |
| tempPosition.applyProjection( camera.projectionMatrix ); | |
| // setup arrays for gl programs | |
| screenPosition.copy( tempPosition ); | |
| screenPositionPixels.x = screenPosition.x * halfViewportWidth + halfViewportWidth; | |
| screenPositionPixels.y = screenPosition.y * halfViewportHeight + halfViewportHeight; | |
| // screen cull | |
| if ( hasVertexTexture || ( | |
| screenPositionPixels.x > 0 && | |
| screenPositionPixels.x < viewport.z && | |
| screenPositionPixels.y > 0 && | |
| screenPositionPixels.y < viewport.w ) ) { | |
| // save current RGB to temp texture | |
| state.activeTexture( gl.TEXTURE0 ); | |
| state.bindTexture( gl.TEXTURE_2D, null ); | |
| state.activeTexture( gl.TEXTURE1 ); | |
| state.bindTexture( gl.TEXTURE_2D, tempTexture ); | |
| gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGB, viewport.x + screenPositionPixels.x - 8, viewport.y + screenPositionPixels.y - 8, 16, 16, 0 ); | |
| // render pink quad | |
| gl.uniform1i( uniforms.renderType, 0 ); | |
| gl.uniform2f( uniforms.scale, scale.x, scale.y ); | |
| gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z ); | |
| state.disable( gl.BLEND ); | |
| state.enable( gl.DEPTH_TEST ); | |
| gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); | |
| // copy result to occlusionMap | |
| state.activeTexture( gl.TEXTURE0 ); | |
| state.bindTexture( gl.TEXTURE_2D, occlusionTexture ); | |
| gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGBA, viewport.x + screenPositionPixels.x - 8, viewport.y + screenPositionPixels.y - 8, 16, 16, 0 ); | |
| // restore graphics | |
| gl.uniform1i( uniforms.renderType, 1 ); | |
| state.disable( gl.DEPTH_TEST ); | |
| state.activeTexture( gl.TEXTURE1 ); | |
| state.bindTexture( gl.TEXTURE_2D, tempTexture ); | |
| gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); | |
| // update object positions | |
| flare.positionScreen.copy( screenPosition ); | |
| if ( flare.customUpdateCallback ) { | |
| flare.customUpdateCallback( flare ); | |
| } else { | |
| flare.updateLensFlares(); | |
| } | |
| // render flares | |
| gl.uniform1i( uniforms.renderType, 2 ); | |
| state.enable( gl.BLEND ); | |
| for ( var j = 0, jl = flare.lensFlares.length; j < jl; j ++ ) { | |
| var sprite = flare.lensFlares[ j ]; | |
| if ( sprite.opacity > 0.001 && sprite.scale > 0.001 ) { | |
| screenPosition.x = sprite.x; | |
| screenPosition.y = sprite.y; | |
| screenPosition.z = sprite.z; | |
| size = sprite.size * sprite.scale / viewport.w; | |
| scale.x = size * invAspect; | |
| scale.y = size; | |
| gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z ); | |
| gl.uniform2f( uniforms.scale, scale.x, scale.y ); | |
| gl.uniform1f( uniforms.rotation, sprite.rotation ); | |
| gl.uniform1f( uniforms.opacity, sprite.opacity ); | |
| gl.uniform3f( uniforms.color, sprite.color.r, sprite.color.g, sprite.color.b ); | |
| state.setBlending( sprite.blending, sprite.blendEquation, sprite.blendSrc, sprite.blendDst ); | |
| renderer.setTexture( sprite.texture, 1 ); | |
| gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); | |
| } | |
| } | |
| } | |
| } | |
| // restore gl | |
| state.enable( gl.CULL_FACE ); | |
| state.enable( gl.DEPTH_TEST ); | |
| state.setDepthWrite( true ); | |
| renderer.resetGLState(); | |
| }; | |
| function createProgram ( shader ) { | |
| var program = gl.createProgram(); | |
| var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER ); | |
| var vertexShader = gl.createShader( gl.VERTEX_SHADER ); | |
| var prefix = "precision " + renderer.getPrecision() + " float;\n"; | |
| gl.shaderSource( fragmentShader, prefix + shader.fragmentShader ); | |
| gl.shaderSource( vertexShader, prefix + shader.vertexShader ); | |
| gl.compileShader( fragmentShader ); | |
| gl.compileShader( vertexShader ); | |
| gl.attachShader( program, fragmentShader ); | |
| gl.attachShader( program, vertexShader ); | |
| gl.linkProgram( program ); | |
| return program; | |
| } | |
| }; | |
| // File:src/renderers/webgl/plugins/SpritePlugin.js | |
| /** | |
| * @author mikael emtinger / http://gomo.se/ | |
| * @author alteredq / http://alteredqualia.com/ | |
| */ | |
| THREE.SpritePlugin = function ( renderer, sprites ) { | |
| var gl = renderer.context; | |
| var state = renderer.state; | |
| var vertexBuffer, elementBuffer; | |
| var program, attributes, uniforms; | |
| var texture; | |
| // decompose matrixWorld | |
| var spritePosition = new THREE.Vector3(); | |
| var spriteRotation = new THREE.Quaternion(); | |
| var spriteScale = new THREE.Vector3(); | |
| function init() { | |
| var vertices = new Float32Array( [ | |
| - 0.5, - 0.5, 0, 0, | |
| 0.5, - 0.5, 1, 0, | |
| 0.5, 0.5, 1, 1, | |
| - 0.5, 0.5, 0, 1 | |
| ] ); | |
| var faces = new Uint16Array( [ | |
| 0, 1, 2, | |
| 0, 2, 3 | |
| ] ); | |
| vertexBuffer = gl.createBuffer(); | |
| elementBuffer = gl.createBuffer(); | |
| gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); | |
| gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW ); | |
| gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); | |
| gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW ); | |
| program = createProgram(); | |
| attributes = { | |
| position: gl.getAttribLocation ( program, 'position' ), | |
| uv: gl.getAttribLocation ( program, 'uv' ) | |
| }; | |
| uniforms = { | |
| uvOffset: gl.getUniformLocation( program, 'uvOffset' ), | |
| uvScale: gl.getUniformLocation( program, 'uvScale' ), | |
| rotation: gl.getUniformLocation( program, 'rotation' ), | |
| scale: gl.getUniformLocation( program, 'scale' ), | |
| color: gl.getUniformLocation( program, 'color' ), | |
| map: gl.getUniformLocation( program, 'map' ), | |
| opacity: gl.getUniformLocation( program, 'opacity' ), | |
| modelViewMatrix: gl.getUniformLocation( program, 'modelViewMatrix' ), | |
| projectionMatrix: gl.getUniformLocation( program, 'projectionMatrix' ), | |
| fogType: gl.getUniformLocation( program, 'fogType' ), | |
| fogDensity: gl.getUniformLocation( program, 'fogDensity' ), | |
| fogNear: gl.getUniformLocation( program, 'fogNear' ), | |
| fogFar: gl.getUniformLocation( program, 'fogFar' ), | |
| fogColor: gl.getUniformLocation( program, 'fogColor' ), | |
| alphaTest: gl.getUniformLocation( program, 'alphaTest' ) | |
| }; | |
| var canvas = document.createElement( 'canvas' ); | |
| canvas.width = 8; | |
| canvas.height = 8; | |
| var context = canvas.getContext( '2d' ); | |
| context.fillStyle = 'white'; | |
| context.fillRect( 0, 0, 8, 8 ); | |
| texture = new THREE.Texture( canvas ); | |
| texture.needsUpdate = true; | |
| } | |
| this.render = function ( scene, camera ) { | |
| if ( sprites.length === 0 ) return; | |
| // setup gl | |
| if ( program === undefined ) { | |
| init(); | |
| } | |
| gl.useProgram( program ); | |
| state.initAttributes(); | |
| state.enableAttribute( attributes.position ); | |
| state.enableAttribute( attributes.uv ); | |
| state.disableUnusedAttributes(); | |
| state.disable( gl.CULL_FACE ); | |
| state.enable( gl.BLEND ); | |
| gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer ); | |
| gl.vertexAttribPointer( attributes.position, 2, gl.FLOAT, false, 2 * 8, 0 ); | |
| gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 ); | |
| gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer ); | |
| gl.uniformMatrix4fv( uniforms.projectionMatrix, false, camera.projectionMatrix.elements ); | |
| state.activeTexture( gl.TEXTURE0 ); | |
| gl.uniform1i( uniforms.map, 0 ); | |
| var oldFogType = 0; | |
| var sceneFogType = 0; | |
| var fog = scene.fog; | |
| if ( fog ) { | |
| gl.uniform3f( uniforms.fogColor, fog.color.r, fog.color.g, fog.color.b ); | |
| if ( fog instanceof THREE.Fog ) { | |
| gl.uniform1f( uniforms.fogNear, fog.near ); | |
| gl.uniform1f( uniforms.fogFar, fog.far ); | |
| gl.uniform1i( uniforms.fogType, 1 ); | |
| oldFogType = 1; | |
| sceneFogType = 1; | |
| } else if ( fog instanceof THREE.FogExp2 ) { | |
| gl.uniform1f( uniforms.fogDensity, fog.density ); | |
| gl.uniform1i( uniforms.fogType, 2 ); | |
| oldFogType = 2; | |
| sceneFogType = 2; | |
| } | |
| } else { | |
| gl.uniform1i( uniforms.fogType, 0 ); | |
| oldFogType = 0; | |
| sceneFogType = 0; | |
| } | |
| // update positions and sort | |
| for ( var i = 0, l = sprites.length; i < l; i ++ ) { | |
| var sprite = sprites[ i ]; | |
| sprite.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, sprite.matrixWorld ); | |
| sprite.z = - sprite.modelViewMatrix.elements[ 14 ]; | |
| } | |
| sprites.sort( painterSortStable ); | |
| // render all sprites | |
| var scale = []; | |
| for ( var i = 0, l = sprites.length; i < l; i ++ ) { | |
| var sprite = sprites[ i ]; | |
| var material = sprite.material; | |
| gl.uniform1f( uniforms.alphaTest, material.alphaTest ); | |
| gl.uniformMatrix4fv( uniforms.modelViewMatrix, false, sprite.modelViewMatrix.elements ); | |
| sprite.matrixWorld.decompose( spritePosition, spriteRotation, spriteScale ); | |
| scale[ 0 ] = spriteScale.x; | |
| scale[ 1 ] = spriteScale.y; | |
| var fogType = 0; | |
| if ( scene.fog && material.fog ) { | |
| fogType = sceneFogType; | |
| } | |
| if ( oldFogType !== fogType ) { | |
| gl.uniform1i( uniforms.fogType, fogType ); | |
| oldFogType = fogType; | |
| } | |
| if ( material.map !== null ) { | |
| gl.uniform2f( uniforms.uvOffset, material.map.offset.x, material.map.offset.y ); | |
| gl.uniform2f( uniforms.uvScale, material.map.repeat.x, material.map.repeat.y ); | |
| } else { | |
| gl.uniform2f( uniforms.uvOffset, 0, 0 ); | |
| gl.uniform2f( uniforms.uvScale, 1, 1 ); | |
| } | |
| gl.uniform1f( uniforms.opacity, material.opacity ); | |
| gl.uniform3f( uniforms.color, material.color.r, material.color.g, material.color.b ); | |
| gl.uniform1f( uniforms.rotation, material.rotation ); | |
| gl.uniform2fv( uniforms.scale, scale ); | |
| state.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst ); | |
| state.setDepthTest( material.depthTest ); | |
| state.setDepthWrite( material.depthWrite ); | |
| if ( material.map && material.map.image && material.map.image.width ) { | |
| renderer.setTexture( material.map, 0 ); | |
| } else { | |
| renderer.setTexture( texture, 0 ); | |
| } | |
| gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 ); | |
| } | |
| // restore gl | |
| state.enable( gl.CULL_FACE ); | |
| renderer.resetGLState(); | |
| }; | |
| function createProgram () { | |
| var program = gl.createProgram(); | |
| var vertexShader = gl.createShader( gl.VERTEX_SHADER ); | |
| var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER ); | |
| gl.shaderSource( vertexShader, [ | |
| 'precision ' + renderer.getPrecision() + ' float;', | |
| 'uniform mat4 modelViewMatrix;', | |
| 'uniform mat4 projectionMatrix;', | |
| 'uniform float rotation;', | |
| 'uniform vec2 scale;', | |
| 'uniform vec2 uvOffset;', | |
| 'uniform vec2 uvScale;', | |
| 'attribute vec2 position;', | |
| 'attribute vec2 uv;', | |
| 'varying vec2 vUV;', | |
| 'void main() {', | |
| 'vUV = uvOffset + uv * uvScale;', | |
| 'vec2 alignedPosition = position * scale;', | |
| 'vec2 rotatedPosition;', | |
| 'rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;', | |
| 'rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;', | |
| 'vec4 finalPosition;', | |
| 'finalPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );', | |
| 'finalPosition.xy += rotatedPosition;', | |
| 'finalPosition = projectionMatrix * finalPosition;', | |
| 'gl_Position = finalPosition;', | |
| '}' | |
| ].join( '\n' ) ); | |
| gl.shaderSource( fragmentShader, [ | |
| 'precision ' + renderer.getPrecision() + ' float;', | |
| 'uniform vec3 color;', | |
| 'uniform sampler2D map;', | |
| 'uniform float opacity;', | |
| 'uniform int fogType;', | |
| 'uniform vec3 fogColor;', | |
| 'uniform float fogDensity;', | |
| 'uniform float fogNear;', | |
| 'uniform float fogFar;', | |
| 'uniform float alphaTest;', | |
| 'varying vec2 vUV;', | |
| 'void main() {', | |
| 'vec4 texture = texture2D( map, vUV );', | |
| 'if ( texture.a < alphaTest ) discard;', | |
| 'gl_FragColor = vec4( color * texture.xyz, texture.a * opacity );', | |
| 'if ( fogType > 0 ) {', | |
| 'float depth = gl_FragCoord.z / gl_FragCoord.w;', | |
| 'float fogFactor = 0.0;', | |
| 'if ( fogType == 1 ) {', | |
| 'fogFactor = smoothstep( fogNear, fogFar, depth );', | |
| '} else {', | |
| 'const float LOG2 = 1.442695;', | |
| 'fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 );', | |
| 'fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );', | |
| '}', | |
| 'gl_FragColor = mix( gl_FragColor, vec4( fogColor, gl_FragColor.w ), fogFactor );', | |
| '}', | |
| '}' | |
| ].join( '\n' ) ); | |
| gl.compileShader( vertexShader ); | |
| gl.compileShader( fragmentShader ); | |
| gl.attachShader( program, vertexShader ); | |
| gl.attachShader( program, fragmentShader ); | |
| gl.linkProgram( program ); | |
| return program; | |
| } | |
| function painterSortStable ( a, b ) { | |
| if ( a.renderOrder !== b.renderOrder ) { | |
| return a.renderOrder - b.renderOrder; | |
| } else if ( a.z !== b.z ) { | |
| return b.z - a.z; | |
| } else { | |
| return b.id - a.id; | |
| } | |
| } | |
| }; | |
| // File:src/Three.Legacy.js | |
| /** | |
| * @author mrdoob / http://mrdoob.com/ | |
| */ | |
| Object.defineProperties( THREE.Box2.prototype, { | |
| empty: { | |
| value: function () { | |
| console.warn( 'THREE.Box2: .empty() has been renamed to .isEmpty().' ); | |
| return this.isEmpty(); | |
| } | |
| }, | |
| isIntersectionBox: { | |
| value: function ( box ) { | |
| console.warn( 'THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().' ); | |
| return this.intersectsBox( box ); | |
| } | |
| } | |
| } ); | |
| Object.defineProperties( THREE.Box3.prototype, { | |
| empty: { | |
| value: function () { | |
| console.warn( 'THREE.Box3: .empty() has been renamed to .isEmpty().' ); | |
| return this.isEmpty(); | |
| } | |
| }, | |
| isIntersectionBox: { | |
| value: function ( box ) { | |
| console.warn( 'THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().' ); | |
| return this.intersectsBox( box ); | |
| } | |
| }, | |
| isIntersectionSphere: { | |
| value: function ( sphere ) { | |
| console.warn( 'THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().' ); | |
| return this.intersectsSphere( sphere ); | |
| } | |
| } | |
| } ); | |
| Object.defineProperties( THREE.Matrix3.prototype, { | |
| multiplyVector3: { | |
| value: function ( vector ) { | |
| console.warn( 'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.' ); | |
| return vector.applyMatrix3( this ); | |
| } | |
| }, | |
| multiplyVector3Array: { | |
| value: function ( a ) { | |
| console.warn( 'THREE.Matrix3: .multiplyVector3Array() has been renamed. Use matrix.applyToVector3Array( array ) instead.' ); | |
| return this.applyToVector3Array( a ); | |
| } | |
| } | |
| } ); | |
| Object.defineProperties( THREE.Matrix4.prototype, { | |
| extractPosition: { | |
| value: function ( m ) { | |
| console.warn( 'THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().' ); | |
| return this.copyPosition( m ); | |
| } | |
| }, | |
| setRotationFromQuaternion: { | |
| value: function ( q ) { | |
| console.warn( 'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().' ); | |
| return this.makeRotationFromQuaternion( q ); | |
| } | |
| }, | |
| multiplyVector3: { | |
| value: function ( vector ) { | |
| console.warn( 'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) or vector.applyProjection( matrix ) instead.' ); | |
| return vector.applyProjection( this ); | |
| } | |
| }, | |
| multiplyVector4: { | |
| value: function ( vector ) { | |
| console.warn( 'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.' ); | |
| return vector.applyMatrix4( this ); | |
| } | |
| }, | |
| multiplyVector3Array: { | |
| value: function ( a ) { | |
| console.warn( 'THREE.Matrix4: .multiplyVector3Array() has been renamed. Use matrix.applyToVector3Array( array ) instead.' ); | |
| return this.applyToVector3Array( a ); | |
| } | |
| }, | |
| rotateAxis: { | |
| value: function ( v ) { | |
| console.warn( 'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.' ); | |
| v.transformDirection( this ); | |
| } | |
| }, | |
| crossVector: { | |
| value: function ( vector ) { | |
| console.warn( 'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.' ); | |
| return vector.applyMatrix4( this ); | |
| } | |
| }, | |
| translate: { | |
| value: function ( v ) { | |
| console.error( 'THREE.Matrix4: .translate() has been removed.' ); | |
| } | |
| }, | |
| rotateX: { | |
| value: function ( angle ) { | |
| console.error( 'THREE.Matrix4: .rotateX() has been removed.' ); | |
| } | |
| }, | |
| rotateY: { | |
| value: function ( angle ) { | |
| console.error( 'THREE.Matrix4: .rotateY() has been removed.' ); | |
| } | |
| }, | |
| rotateZ: { | |
| value: function ( angle ) { | |
| console.error( 'THREE.Matrix4: .rotateZ() has been removed.' ); | |
| } | |
| }, | |
| rotateByAxis: { | |
| value: function ( axis, angle ) { | |
| console.error( 'THREE.Matrix4: .rotateByAxis() has been removed.' ); | |
| } | |
| } | |
| } ); | |
| Object.defineProperties( THREE.Plane.prototype, { | |
| isIntersectionLine: { | |
| value: function ( line ) { | |
| console.warn( 'THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().' ); | |
| return this.intersectsLine( line ); | |
| } | |
| } | |
| } ); | |
| Object.defineProperties( THREE.Quaternion.prototype, { | |
| multiplyVector3: { | |
| value: function ( vector ) { | |
| console.warn( 'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.' ); | |
| return vector.applyQuaternion( this ); | |
| } | |
| } | |
| } ); | |
| Object.defineProperties( THREE.Ray.prototype, { | |
| isIntersectionBox: { | |
| value: function ( box ) { | |
| console.warn( 'THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().' ); | |
| return this.intersectsBox( box ); | |
| } | |
| }, | |
| isIntersectionPlane: { | |
| value: function ( plane ) { | |
| console.warn( 'THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().' ); | |
| return this.intersectsPlane( plane ); | |
| } | |
| }, | |
| isIntersectionSphere: { | |
| value: function ( sphere ) { | |
| console.warn( 'THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().' ); | |
| return this.intersectsSphere( sphere ); | |
| } | |
| } | |
| } ); | |
| Object.defineProperties( THREE.Vector3.prototype, { | |
| setEulerFromRotationMatrix: { | |
| value: function () { | |
| console.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' ); | |
| } | |
| }, | |
| setEulerFromQuaternion: { | |
| value: function () { | |
| console.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' ); | |
| } | |
| }, | |
| getPositionFromMatrix: { | |
| value: function ( m ) { | |
| console.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' ); | |
| return this.setFromMatrixPosition( m ); | |
| } | |
| }, | |
| getScaleFromMatrix: { | |
| value: function ( m ) { | |
| console.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' ); | |
| return this.setFromMatrixScale( m ); | |
| } | |
| }, | |
| getColumnFromMatrix: { | |
| value: function ( index, matrix ) { | |
| console.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' ); | |
| return this.setFromMatrixColumn( index, matrix ); | |
| } | |
| } | |
| } ); | |
| // | |
| THREE.Face4 = function ( a, b, c, d, normal, color, materialIndex ) { | |
| console.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.' ); | |
| return new THREE.Face3( a, b, c, normal, color, materialIndex ); | |
| }; | |
| // | |
| Object.defineProperties( THREE.Object3D.prototype, { | |
| eulerOrder: { | |
| get: function () { | |
| console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' ); | |
| return this.rotation.order; | |
| }, | |
| set: function ( value ) { | |
| console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' ); | |
| this.rotation.order = value; | |
| } | |
| }, | |
| getChildByName: { | |
| value: function ( name ) { | |
| console.warn( 'THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().' ); | |
| return this.getObjectByName( name ); | |
| } | |
| }, | |
| renderDepth: { | |
| set: function ( value ) { | |
| console.warn( 'THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.' ); | |
| } | |
| }, | |
| translate: { | |
| value: function ( distance, axis ) { | |
| console.warn( 'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.' ); | |
| return this.translateOnAxis( axis, distance ); | |
| } | |
| }, | |
| useQuaternion: { | |
| get: function () { | |
| console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' ); | |
| }, | |
| set: function ( value ) { | |
| console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' ); | |
| } | |
| } | |
| } ); | |
| // | |
| Object.defineProperties( THREE, { | |
| PointCloud: { | |
| value: function ( geometry, material ) { | |
| console.warn( 'THREE.PointCloud has been renamed to THREE.Points.' ); | |
| return new THREE.Points( geometry, material ); | |
| } | |
| }, | |
| ParticleSystem: { | |
| value: function ( geometry, material ) { | |
| console.warn( 'THREE.ParticleSystem has been renamed to THREE.Points.' ); | |
| return new THREE.Points( geometry, material ); | |
| } | |
| } | |
| } ); | |
| // | |
| Object.defineProperties( THREE.Light.prototype, { | |
| onlyShadow: { | |
| set: function ( value ) { | |
| console.warn( 'THREE.Light: |
View Raw
(Sorry about that, but we can’t show files that are this big right now.)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment