Qingran-Gen/chenhai-ui/public/lib/mars3d_old/thirdParty/meshVisualizer/CesiumMeshVisualizer.js

// import * as mars3d from "mars3d"
// const Cesium = mars3d.Cesium

(function () {

    var requirejs, require, define;
    (function (undef) {
        var main, req, makeMap, handlers,
            defined = {},
            waiting = {},
            config = {},
            defining = {},
            hasOwn = Object.prototype.hasOwnProperty,
            aps = [].slice,
            jsSuffixRegExp = /\.js$/;

        function hasProp(obj, prop) {
            return hasOwn.call(obj, prop);
        }

        /**
         * Given a relative module name, like ./something, normalize it to
         * a real name that can be mapped to a path.
         * @param {String} name the relative name
         * @param {String} baseName a real name that the name arg is relative
         * to.
         * @returns {String} normalized name
         */
        function normalize(name, baseName) {
            var nameParts, nameSegment, mapValue, foundMap, lastIndex,
                foundI, foundStarMap, starI, i, j, part, normalizedBaseParts,
                baseParts = baseName && baseName.split("/"),
                map = config.map,
                starMap = (map && map['*']) || {};

            //Adjust any relative paths.
            if (name) {
                name = name.split('/');
                lastIndex = name.length - 1;

                // If wanting node ID compatibility, strip .js from end
                // of IDs. Have to do this here, and not in nameToUrl
                // because node allows either .js or non .js to map
                // to same file.
                if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
                    name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
                }

                // Starts with a '.' so need the baseName
                if (name[0].charAt(0) === '.' && baseParts) {
                    //Convert baseName to array, and lop off the last part,
                    //so that . matches that 'directory' and not name of the baseName's
                    //module. For instance, baseName of 'one/two/three', maps to
                    //'one/two/three.js', but we want the directory, 'one/two' for
                    //this normalization.
                    normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
                    name = normalizedBaseParts.concat(name);
                }

                //start trimDots
                for (i = 0; i < name.length; i++) {
                    part = name[i];
                    if (part === '.') {
                        name.splice(i, 1);
                        i -= 1;
                    } else if (part === '..') {
                        // If at the start, or previous value is still ..,
                        // keep them so that when converted to a path it may
                        // still work when converted to a path, even though
                        // as an ID it is less than ideal. In larger point
                        // releases, may be better to just kick out an error.
                        if (i === 0 || (i === 1 && name[2] === '..') || name[i - 1] === '..') {
                            continue;
                        } else if (i > 0) {
                            name.splice(i - 1, 2);
                            i -= 2;
                        }
                    }
                }
                //end trimDots

                name = name.join('/');
            }

            //Apply map config if available.
            if ((baseParts || starMap) && map) {
                nameParts = name.split('/');

                for (i = nameParts.length; i > 0; i -= 1) {
                    nameSegment = nameParts.slice(0, i).join("/");

                    if (baseParts) {
                        //Find the longest baseName segment match in the config.
                        //So, do joins on the biggest to smallest lengths of baseParts.
                        for (j = baseParts.length; j > 0; j -= 1) {
                            mapValue = map[baseParts.slice(0, j).join('/')];

                            //baseName segment has  config, find if it has one for
                            //this name.
                            if (mapValue) {
                                mapValue = mapValue[nameSegment];
                                if (mapValue) {
                                    //Match, update name to the new value.
                                    foundMap = mapValue;
                                    foundI = i;
                                    break;
                                }
                            }
                        }
                    }

                    if (foundMap) {
                        break;
                    }

                    //Check for a star map match, but just hold on to it,
                    //if there is a shorter segment match later in a matching
                    //config, then favor over this star map.
                    if (!foundStarMap && starMap && starMap[nameSegment]) {
                        foundStarMap = starMap[nameSegment];
                        starI = i;
                    }
                }

                if (!foundMap && foundStarMap) {
                    foundMap = foundStarMap;
                    foundI = starI;
                }

                if (foundMap) {
                    nameParts.splice(0, foundI, foundMap);
                    name = nameParts.join('/');
                }
            }

            return name;
        }

        function makeRequire(relName, forceSync) {
            return function () {
                //A version of a require function that passes a moduleName
                //value for items that may need to
                //look up paths relative to the moduleName
                var args = aps.call(arguments, 0);

                //If first arg is not require('string'), and there is only
                //one arg, it is the array form without a callback. Insert
                //a null so that the following concat is correct.
                if (typeof args[0] !== 'string' && args.length === 1) {
                    args.push(null);
                }
                return req.apply(undef, args.concat([relName, forceSync]));
            };
        }

        function makeNormalize(relName) {
            return function (name) {
                return normalize(name, relName);
            };
        }

        function makeLoad(depName) {
            return function (value) {
                defined[depName] = value;
            };
        }

        function callDep(name) {
            if (hasProp(waiting, name)) {
                var args = waiting[name];
                delete waiting[name];
                defining[name] = true;
                main.apply(undef, args);
            }

            if (!hasProp(defined, name) && !hasProp(defining, name)) {
                throw new Error('No ' + name);
            }
            return defined[name];
        }

        //Turns a plugin!resource to [plugin, resource]
        //with the plugin being undefined if the name
        //did not have a plugin prefix.
        function splitPrefix(name) {
            var prefix,
                index = name ? name.indexOf('!') : -1;
            if (index > -1) {
                prefix = name.substring(0, index);
                name = name.substring(index + 1, name.length);
            }
            return [prefix, name];
        }

        //Creates a parts array for a relName where first part is plugin ID,
        //second part is resource ID. Assumes relName has already been normalized.
        function makeRelParts(relName) {
            return relName ? splitPrefix(relName) : [];
        }

        /**
         * Makes a name map, normalizing the name, and using a plugin
         * for normalization if necessary. Grabs a ref to plugin
         * too, as an optimization.
         */
        makeMap = function (name, relParts) {
            var plugin,
                parts = splitPrefix(name),
                prefix = parts[0],
                relResourceName = relParts[1];

            name = parts[1];

            if (prefix) {
                prefix = normalize(prefix, relResourceName);
                plugin = callDep(prefix);
            }

            //Normalize according
            if (prefix) {
                if (plugin && plugin.normalize) {
                    name = plugin.normalize(name, makeNormalize(relResourceName));
                } else {
                    name = normalize(name, relResourceName);
                }
            } else {
                name = normalize(name, relResourceName);
                parts = splitPrefix(name);
                prefix = parts[0];
                name = parts[1];
                if (prefix) {
                    plugin = callDep(prefix);
                }
            }

            //Using ridiculous property names for space reasons
            return {
                f: prefix ? prefix + '!' + name : name, //fullName
                n: name,
                pr: prefix,
                p: plugin
            };
        };

        function makeConfig(name) {
            return function () {
                return (config && config.config && config.config[name]) || {};
            };
        }

        handlers = {
            require: function (name) {
                return makeRequire(name);
            },
            exports: function (name) {
                var e = defined[name];
                if (typeof e !== 'undefined') {
                    return e;
                } else {
                    return (defined[name] = {});
                }
            },
            module: function (name) {
                return {
                    id: name,
                    uri: '',
                    exports: defined[name],
                    config: makeConfig(name)
                };
            }
        };

        main = function (name, deps, callback, relName) {
            var cjsModule, depName, ret, map, i, relParts,
                args = [],
                callbackType = typeof callback,
                usingExports;

            //Use name if no relName
            relName = relName || name;
            relParts = makeRelParts(relName);

            //Call the callback to define the module, if necessary.
            if (callbackType === 'undefined' || callbackType === 'function') {
                //Pull out the defined dependencies and pass the ordered
                //values to the callback.
                //Default to [require, exports, module] if no deps
                deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
                for (i = 0; i < deps.length; i += 1) {
                    map = makeMap(deps[i], relParts);
                    depName = map.f;

                    //Fast path CommonJS standard dependencies.
                    if (depName === "require") {
                        args[i] = handlers.require(name);
                    } else if (depName === "exports") {
                        //CommonJS module spec 1.1
                        args[i] = handlers.exports(name);
                        usingExports = true;
                    } else if (depName === "module") {
                        //CommonJS module spec 1.1
                        cjsModule = args[i] = handlers.module(name);
                    } else if (hasProp(defined, depName) ||
                               hasProp(waiting, depName) ||
                               hasProp(defining, depName)) {
                        args[i] = callDep(depName);
                    } else if (map.p) {
                        map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
                        args[i] = defined[depName];
                    } else {
                        throw new Error(name + ' missing ' + depName);
                    }
                }

                ret = callback ? callback.apply(defined[name], args) : undefined;

                if (name) {
                    //If setting exports via "module" is in play,
                    //favor that over return value and exports. After that,
                    //favor a non-undefined return value over exports use.
                    if (cjsModule && cjsModule.exports !== undef &&
                            cjsModule.exports !== defined[name]) {
                        defined[name] = cjsModule.exports;
                    } else if (ret !== undef || !usingExports) {
                        //Use the return value from the function.
                        defined[name] = ret;
                    }
                }
            } else if (name) {
                //May just be an object definition for the module. Only
                //worry about defining if have a module name.
                defined[name] = callback;
            }
        };

        requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
            if (typeof deps === "string") {
                if (handlers[deps]) {
                    //callback in this case is really relName
                    return handlers[deps](callback);
                }
                //Just return the module wanted. In this scenario, the
                //deps arg is the module name, and second arg (if passed)
                //is just the relName.
                //Normalize module name, if it contains . or ..
                return callDep(makeMap(deps, makeRelParts(callback)).f);
            } else if (!deps.splice) {
                //deps is a config object, not an array.
                config = deps;
                if (config.deps) {
                    req(config.deps, config.callback);
                }
                if (!callback) {
                    return;
                }

                if (callback.splice) {
                    //callback is an array, which means it is a dependency list.
                    //Adjust args if there are dependencies
                    deps = callback;
                    callback = relName;
                    relName = null;
                } else {
                    deps = undef;
                }
            }

            //Support require(['a'])
            callback = callback || function () { };

            //If relName is a function, it is an errback handler,
            //so remove it.
            if (typeof relName === 'function') {
                relName = forceSync;
                forceSync = alt;
            }

            //Simulate async callback;
            if (forceSync) {
                main(undef, deps, callback, relName);
            } else {
                //Using a non-zero value because of concern for what old browsers
                //do, and latest browsers "upgrade" to 4 if lower value is used:
                //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
                //If want a value immediately, use require('id') instead -- something
                //that works in almond on the global level, but not guaranteed and
                //unlikely to work in other AMD implementations.
                setTimeout(function () {
                    main(undef, deps, callback, relName);
                }, 4);
            }

            return req;
        };

        /**
         * Just drops the config on the floor, but returns req in case
         * the config return value is used.
         */
        req.config = function (cfg) {
            return req(cfg);
        };

        /**
         * Expose module registry for debugging and tooling
         */
        requirejs._defined = defined;

        define = function (name, deps, callback) {
            if (typeof name !== 'string') {
                throw new Error('See almond README: incorrect module build, no module name');
            }

            //This module may not have dependencies
            if (!deps.splice) {
                //deps is not an array, so probably means
                //an object literal or factory function for
                //the value. Adjust args.
                callback = deps;
                deps = [];
            }

            if (!hasProp(defined, name) && !hasProp(waiting, name)) {
                waiting[name] = [name, deps, callback];
            }
        };

        define.amd = {
            jQuery: true
        };
    }());
    /**
   *
   * @namespace Cesium
   */
    //----CesiumMeshVisualizer----
define('Core/RendererUtils',[],function () {
    var Cartesian3 = Cesium.Cartesian3;
    var CesiumMath = Cesium.Math;
    var yUpToZUp = Cesium.Matrix4.fromRotationTranslation(Cesium.Matrix3.fromRotationX(CesiumMath.PI_OVER_TWO));
    var scratchTranslation = new Cesium.Cartesian3();
    var scratchQuaternion = new Cesium.Quaternion();
    var scratchScale = new Cesium.Cartesian3();
    var scratchTranslationQuaternionRotationScale = new Cesium.Matrix4();
    var computeModelMatrix = new Cesium.Matrix4();
    var scratchPosition = new Cesium.Cartesian3();
    var clearCommandScratch = new Cesium.ClearCommand({
        color: new Cesium.Color(0.0, 0.0, 0.0, 0.0)
    });

    /**
    *
    *@constructor
    *@memberof Cesium
    */
    function RendererUtils() { }
    /**
    *使用帧缓冲技术，执行渲染命令，渲染到纹理
    *@param {Cesium.DrawCommand|Array<Cesium.DrawCommand>}drawCommand 渲染命令（集合）
    *@param {Cesium.FrameState}frameState 帧状态对象，可以从Cesium.Scene中获取
    *@param {Cesium.Texture}outpuTexture 将渲染到的目标纹理对象
    *@param {Cesium.Texture}[outputDepthTexture] 可选，输出的深度纹理
    */
    RendererUtils.renderToTexture = function (drawCommand, frameState, outputTexture, outputDepthTexture) {
        var drawCommands = Array.isArray(drawCommand) ? drawCommand : [drawCommand];
        var context = frameState.context;

        var framebuffer = null, destroy = false;
        if (outputTexture instanceof Cesium.Framebuffer) {
            framebuffer = outputTexture;
        }
        if (!framebuffer) {
            framebuffer = new Cesium.Framebuffer({
                context: context,
                colorTextures: [outputTexture],
                destroyAttachments: false,
                depthTexture: outputDepthTexture
            });
            destroy = true;
        }

        var clearCommand = clearCommandScratch;
        clearCommand.framebuffer = framebuffer;
        clearCommand.renderState = frameState.renderState;
        clearCommand.execute(context);

        drawCommands.forEach(function (drawCommand) {
            drawCommand.framebuffer = framebuffer;
            drawCommand.execute(context);
        });
        if (destroy) {
            framebuffer.destroy();
        }
    }

    /**
    *
    *@param {Cesium.Matrix4}srcMatrix
    *@param {Cesium.Matrix4}dstMatrix
    *@param {Cesium.Matrix4}
    */
    RendererUtils.yUp2Zup = function (srcMatrix, dstMatrix) {
        return Cesium.Matrix4.multiplyTransformation(srcMatrix, yUpToZUp, dstMatrix);
    }
    /**
    *平移、旋转或缩放，返回计算之后的模型转换矩阵
    *@param {Cesium.Cartesian3}[translation=undefined]
    *@param {Object}[rotation=undefined] 旋转参数
    *@param {Cesium.Cartesian3}[rotation.axis] 旋转轴
    *@param {Number}[rotation.angle] 旋转角度
    *@param {Cesium.Cartesian3}[rotation.scale] 缩放
    *@param {Cesium.Matrix4}[outModelMatrix] 计算结果矩阵，和返回值一样，但是传递此参数时则返回值不是新创建的Cesium.Matrix4实例
    *@return {Cesium.Matrix4}
    */
    RendererUtils.computeModelMatrix = function (srcModelMatrix, translation, rotation, scale, outModelMatrix) {
        if (arguments.length == 0) {
            return srcModelMatrix;
        }
        var Matrix4 = Cesium.Matrix4;
        if (!outModelMatrix) {
            outModelMatrix = new Matrix4();
        }
        Matrix4.clone(srcModelMatrix, outModelMatrix);

        if (!translation) {
            scratchTranslation.x = 0;
            scratchTranslation.y = 0;
            scratchTranslation.z = 0;
        }
        scratchTranslation.x = translation.x;
        scratchTranslation.y = translation.y;
        scratchTranslation.z = translation.z;

        if (!scale) {
            scratchScale.x = 0;
            scratchScale.y = 0;
            scratchScale.z = 0;
        }
        scratchScale.x = scale.x;
        scratchScale.y = scale.y;
        scratchScale.z = scale.z;

        if (rotation instanceof Cesium.Quaternion) {
            Cesium.Quaternion.clone(rotation, scratchQuaternion);
        } else {
            var axis = rotation.axis;
            var angle = rotation.angle;
            Cesium.Quaternion.fromAxisAngle(
                    new Cartesian3(axis.x, axis.y, axis.z),//axis.y=1 y是旋转轴
                    CesiumMath.toRadians(angle),
                    scratchQuaternion
                );
        }

        //translate,rotate,scale

        Matrix4.fromTranslationQuaternionRotationScale(
            scratchTranslation, scratchQuaternion,
            scratchScale, scratchTranslationQuaternionRotationScale);

        Matrix4.multiplyTransformation(
            outModelMatrix,
            scratchTranslationQuaternionRotationScale,
            outModelMatrix);
        return outModelMatrix;
    }

    return RendererUtils;

});
define('Core/Rotation',[],function () {

    /**
    *
    *@param {Cesium.Cartesian3}axis 旋转轴
    *@param {Number}angle 旋转角度
    *
    *@property {Cesium.Cartesian3}axis 旋转轴
    *@property {Number}angle 旋转角度
    *@property {Cesium.Event}paramChanged
    *@constructor
    *@memberof Cesium
    */
    function Rotation(axis, angle) {
        this._axis = axis;
        this._angle = angle;
        this.paramChanged = new Cesium.Event();
    }
    Object.defineProperties(Rotation.prototype, {
        axis: {
            set: function (val) {
                if (val.x != this._axis.x
                    || val.y != this._axis.y
                    || val.z != this._axis.z) {
                    this._axis = val;
                    this.paramChanged.raiseEvent();
                }
                this._axis = val;
            },
            get: function () {
                return this._axis;
            }
        },
        angle: {
            set: function (val) {
                if (val != this._angle) {
                    this._angle = val;
                    this.paramChanged.raiseEvent();
                }
                this._angle = val;
            },
            get: function () {
                return this._angle;
            }
        }
    })

    return Rotation;
});
define('Util/CSG',[],function () {

    // Constructive Solid Geometry (CSG) is a modeling technique that uses Boolean
    // operations like union and intersection to combine 3D solids. This library
    // implements CSG operations on meshes elegantly and concisely using BSP trees,
    // and is meant to serve as an easily understandable implementation of the
    // algorithm. All edge cases involving overlapping coplanar polygons in both
    // solids are correctly handled.
    //
    // Example usage:
    //
    //     var cube = CSG.cube();
    //     var sphere = CSG.sphere({ radius: 1.3 });
    //     var polygons = cube.subtract(sphere).toPolygons();
    //
    // ## Implementation Details
    //
    // All CSG operations are implemented in terms of two functions, `clipTo()` and
    // `invert()`, which remove parts of a BSP tree inside another BSP tree and swap
    // solid and empty space, respectively. To find the union of `a` and `b`, we
    // want to remove everything in `a` inside `b` and everything in `b` inside `a`,
    // then combine polygons from `a` and `b` into one solid:
    //
    //     a.clipTo(b);
    //     b.clipTo(a);
    //     a.build(b.allPolygons());
    //
    // The only tricky part is handling overlapping coplanar polygons in both trees.
    // The code above keeps both copies, but we need to keep them in one tree and
    // remove them in the other tree. To remove them from `b` we can clip the
    // inverse of `b` against `a`. The code for union now looks like this:
    //
    //     a.clipTo(b);
    //     b.clipTo(a);
    //     b.invert();
    //     b.clipTo(a);
    //     b.invert();
    //     a.build(b.allPolygons());
    //
    // Subtraction and intersection naturally follow from set operations. If
    // union is `A | B`, subtraction is `A - B = ~(~A | B)` and intersection is
    // `A & B = ~(~A | ~B)` where `~` is the complement operator.
    //
    // ## License
    //
    // Copyright (c) 2011 Evan Wallace (http://madebyevan.com/), under the MIT license.

    // # class CSG

    // Holds a binary space partition tree representing a 3D solid. Two solids can
    // be combined using the `union()`, `subtract()`, and `intersect()` methods.


    /**
    *源码参见{@link https://github.com/jscad/csg.js} <br/>
    *Constructive Solid Geometry (CSG) is a modeling technique that uses Boolean<br/>
    *operations like union and intersection to combine 3D solids. This library<br/>
    *implements CSG operations on meshes elegantly and concisely using BSP trees,<br/>
    *and is meant to serve as an easily understandable implementation of the<br/>
    *algorithm. All edge cases involving overlapping coplanar polygons in both<br/>
    *solids are correctly handled.<br/>
    *
    *@example

        MeshVisualizer = Cesium.MeshVisualizer;
        Mesh = Cesium.Mesh;
        MeshMaterial = Cesium.MeshMaterial;
        CSG = Cesium.CSG;
        GeometryUtils = Cesium.GeometryUtils;
         //示例1:
         var cube = CSG.cube();
         var sphere = CSG.sphere({ radius: 1.3 });
         var polygons = cube.subtract(sphere).toPolygons();


         //示例2：
        var center = Cesium.Cartesian3.fromDegrees(homePosition[0], homePosition[1], 50000);
        var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);

        var meshVisualizer = new MeshVisualizer({
            modelMatrix: modelMatrix,
            up: { z: 1 }
        });
        viewer.scene.primitives.add(meshVisualizer);

        var material = new MeshMaterial({
            defaultColor: "rgba(0,0,255,1.0)",
            wireframe: true,
            side: MeshMaterial.Sides.DOUBLE
        });

        //创建盒子
        var dimensions = new Cesium.Cartesian3(100000, 50000, 50000);
        var boxGeometry = Cesium.BoxGeometry.createGeometry(Cesium.BoxGeometry.fromDimensions({
            dimensions: dimensions,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY
        }));
        var box = GeometryUtils.toCSG(boxGeometry);
        var boxMesh = new Mesh(box, material);
        meshVisualizer.add(boxMesh);

        //创建球体
        var sphere = new Cesium.SphereGeometry({
            radius: 50000.0,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY
        });
        sphere = Cesium.SphereGeometry.createGeometry(sphere);
        sphere = CSG.toCSG(sphere);
        var sphereMesh = new Mesh(sphere, material);
        sphereMesh.position = new Cesium.Cartesian3(100000, 0, 0)
        meshVisualizer.add(sphereMesh);

        //并
        var unionResult = box.union(sphere);
        var unionResultMesh = new Mesh(unionResult, material);
        unionResultMesh.position = new Cesium.Cartesian3(300000, 0, 0)
        meshVisualizer.add(unionResultMesh);

        //交
        var intersectResult = box.intersect(sphere);
        var intersectResultMesh = new Mesh(intersectResult, material);
        intersectResultMesh.position = new Cesium.Cartesian3(500000, 0, 0)
        meshVisualizer.add(intersectResultMesh);

        //球体减盒子
        var subResult = sphere.subtract(box);
        var subResultMesh = new Mesh(subResult, material);
        subResultMesh.position = new Cesium.Cartesian3(700000, 0, 0)
        meshVisualizer.add(subResultMesh);

        //盒子减球体
        var subResult2 = box.subtract(sphere);
        var subResultMesh2 = new Mesh(subResult2, material);
        subResultMesh2.position = new Cesium.Cartesian3(900000, 0, 0)
        meshVisualizer.add(subResultMesh2);

        //渲染CSG创建的几何体
        var cube = CSG.cube({
            center: [0, 0, 0],
            radius: 20000
        });
        var cubeMtl = new MeshMaterial({
            defaultColor: "rgba(255,0,0,1)"
        });
        meshVisualizer.add(new Mesh({
            geometry: cube,
            material: cubeMtl,
            position: new Cesium.Cartesian3(-100000, 0, 0)
        }));
    *@memberof Cesium
    *@constructor
    */
    function CSG() {
        this.polygons = [];
    };


    /**
    *Construct a CSG solid from a list of `CSG.Polygon` instances.
    *@param {Array<Cesium.CSG.Polygon>}
    *@param {Array<Cesium.CSG>}
    */
    CSG.fromPolygons = function (polygons) {
        var csg = new CSG();
        csg.polygons = polygons;
        return csg;
    };

    CSG.prototype = {
        /**
        *@return {Cesium.CSG}
        */
        clone: function () {
            var csg = new CSG();
            csg.polygons = this.polygons.map(function (p) { return p.clone(); });
            return csg;
        },
        /**
        *
        *@return {Array<Cesium.CSG.Polygon>}
        */
        toPolygons: function () {
            return this.polygons;
        },

        /**
        * Return a new CSG solid representing space in either this solid or in the<br/>
        * solid `csg`. Neither this solid nor the solid `csg` are modified.<br/>
        * <br/>
        *     A.union(B)<br/>
        * <br/>
        *<pre><code>
        *     +-------+            +-------+
        *     |       |            |       |
        *     |   A   |            |       |
        *     |    +--+----+   =   |       +----+
        *     +----+--+    |       +----+       |
        *          |   B   |            |       |
        *          |       |            |       |
        *          +-------+            +-------+
        *</code></pre>
        * @param {Cesium.CSG}csg
        * @return {Cesium.CSG}
        */
        union: function (csg) {
            var a = new CSG.Node(this.clone().polygons);
            var b = new CSG.Node(csg.clone().polygons);
            a.clipTo(b);
            b.clipTo(a);
            b.invert();
            b.clipTo(a);
            b.invert();
            a.build(b.allPolygons());
            return CSG.fromPolygons(a.allPolygons());
        },

        /**
         * Return a new CSG solid representing space in this solid but not in the<br/>
         * solid `csg`. Neither this solid nor the solid `csg` are modified.<br/>
         * <br/>
         *     A.subtract(B)<br/>
         * <br/>
         *<pre><code>
         *     +-------+            +-------+
         *     |       |            |       |
         *     |   A   |            |       |
         *     |    +--+----+   =   |    +--+
         *     +----+--+    |       +----+
         *          |   B   |
         *          |       |
         *          +-------+
         *
         *</code></pre>
         * @param {Cesium.CSG}csg
         * @return {Cesium.CSG}
         */
        subtract: function (csg) {
            var a = new CSG.Node(this.clone().polygons);
            var b = new CSG.Node(csg.clone().polygons);
            a.invert();
            a.clipTo(b);
            b.clipTo(a);
            b.invert();
            b.clipTo(a);
            b.invert();
            a.build(b.allPolygons());
            a.invert();
            return CSG.fromPolygons(a.allPolygons());
        },

        /**
         * Return a new CSG solid representing space both this solid and in the<br/>
         * solid `csg`. Neither this solid nor the solid `csg` are modified.<br/>
         * <br/>
         *     A.intersect(B)<br/>
         * <br/>
         *<pre><code>
         *     +-------+
         *     |       |
         *     |   A   |
         *     |    +--+----+   =   +--+
         *     +----+--+    |       +--+
         *          |   B   |
         *          |       |
         *          +-------+
         *
         *</code></pre>
         * @param {Cesium.CSG}csg
         * @return {Cesium.CSG}
         */
        intersect: function (csg) {
            var a = new CSG.Node(this.clone().polygons);
            var b = new CSG.Node(csg.clone().polygons);
            a.invert();
            b.clipTo(a);
            b.invert();
            a.clipTo(b);
            b.clipTo(a);
            a.build(b.allPolygons());
            a.invert();
            return CSG.fromPolygons(a.allPolygons());
        },

        /**
         * Return a new CSG solid with solid and empty space switched. This solid is
         * not modified.
         * @return {Cesium.CSG}
         */
        inverse: function () {
            var csg = this.clone();
            csg.polygons.map(function (p) { p.flip(); });
            return csg;
        }
    };

    /**
    * Construct an axis-aligned solid cuboid. Optional parameters are `center` and<br/>
    * `radius`, which default to `[0, 0, 0]` and `[1, 1, 1]`. The radius can be<br/>
    * specified using a single number or a list of three numbers, one for each axis.<br/>
    *
    *@example
    *
    *     var cube = CSG.cube({
    *       center: [0, 0, 0],
    *       radius: 1
    *     });
    *@memberof Cesium.CSG
    *@param {Object}options
    *@param {Array<Number>|Cesium.CSG.Vector}[options.center=[0, 0, 0]]
    *@param {Number|Array<Number>|Cesium.CSG.Vector}[options.radius=1]
    *@return {Cesium.CSG}
    */
    CSG.cube = function (options) {
        options = options || {};
        var c = new CSG.Vector(options.center || [0, 0, 0]);
        var r = !options.radius ? [1, 1, 1] : options.radius.length ?
                 options.radius : [options.radius, options.radius, options.radius];
        return CSG.fromPolygons([
          [[0, 4, 6, 2], [-1, 0, 0]],
          [[1, 3, 7, 5], [+1, 0, 0]],
          [[0, 1, 5, 4], [0, -1, 0]],
          [[2, 6, 7, 3], [0, +1, 0]],
          [[0, 2, 3, 1], [0, 0, -1]],
          [[4, 5, 7, 6], [0, 0, +1]]
        ].map(function (info) {
            return new CSG.Polygon(info[0].map(function (i) {
                var pos = new CSG.Vector(
                  c.x + r[0] * (2 * !!(i & 1) - 1),
                  c.y + r[1] * (2 * !!(i & 2) - 1),
                  c.z + r[2] * (2 * !!(i & 4) - 1)
                );
                return new CSG.Vertex(pos, new CSG.Vector(info[1]));
            }));
        }));
    };

    /**
    * Construct a solid sphere. Optional parameters are `center`, `radius`,<br/>
    * `slices`, and `stacks`, which default to `[0, 0, 0]`, `1`, `16`, and `8`.<br/>
    * The `slices` and `stacks` parameters control the tessellation along the<br/>
    * longitude and latitude directions.<br/>
    *
    *@example
    *
    *     var sphere = CSG.sphere({
    *       center: [0, 0, 0],
    *       radius: 1,
    *       slices: 16,
    *       stacks: 8
    *     });
    *@memberof Cesium.CSG
    *@param {Object}options
    *@param {Array<Number>|Cesium.CSG.Vector}[options.center=[0, 0, 0]]
    *@param {Number}[options.radius=1]
    *@param {Number}[options.slices=16]
    *@param {Number}[options.stacks=8]
    *@return {Cesium.CSG}
    */
    CSG.sphere = function (options) {
        options = options || {};
        var c = new CSG.Vector(options.center || [0, 0, 0]);
        var r = options.radius || 1;
        var slices = options.slices || 16;
        var stacks = options.stacks || 8;
        var polygons = [], vertices;
        function vertex(theta, phi) {
            theta *= Math.PI * 2;
            phi *= Math.PI;
            var dir = new CSG.Vector(
              Math.cos(theta) * Math.sin(phi),
              Math.cos(phi),
              Math.sin(theta) * Math.sin(phi)
            );
            vertices.push(new CSG.Vertex(c.plus(dir.times(r)), dir));
        }
        for (var i = 0; i < slices; i++) {
            for (var j = 0; j < stacks; j++) {
                vertices = [];
                vertex(i / slices, j / stacks);
                if (j > 0) vertex((i + 1) / slices, j / stacks);
                if (j < stacks - 1) vertex((i + 1) / slices, (j + 1) / stacks);
                vertex(i / slices, (j + 1) / stacks);
                polygons.push(new CSG.Polygon(vertices));
            }
        }
        return CSG.fromPolygons(polygons);
    };

    /**
    * Construct a solid cylinder. Optional parameters are `start`, `end`,<br/>
    * `radius`, and `slices`, which default to `[0, -1, 0]`, `[0, 1, 0]`, `1`, and<br/>
    * `16`. The `slices` parameter controls the tessellation.<br/>
    *
    *@example
    *
    *     var cylinder = CSG.cylinder({
    *       start: [0, -1, 0],
    *       end: [0, 1, 0],
    *       radius: 1,
    *       slices: 16
    *     });
    *@memberof Cesium.CSG
    *@param {Object}options
    *@param {Array<Number>|Cesium.CSG.Vector}[options.start=[0, -1, 0]]
    *@param {Array<Number>|Cesium.CSG.Vector}[options.end=[0, -1, 0]]
    *@param {Number}[options.radius=1]
    *@param {Number}[options.slices=16]
    *@return {Cesium.CSG}
    */
    CSG.cylinder = function (options) {
        options = options || {};
        var s = new CSG.Vector(options.start || [0, -1, 0]);
        var e = new CSG.Vector(options.end || [0, 1, 0]);
        var ray = e.minus(s);
        var r = options.radius || 1;
        var slices = options.slices || 16;
        var axisZ = ray.unit(), isY = (Math.abs(axisZ.y) > 0.5);
        var axisX = new CSG.Vector(isY, !isY, 0).cross(axisZ).unit();
        var axisY = axisX.cross(axisZ).unit();
        var start = new CSG.Vertex(s, axisZ.negated());
        var end = new CSG.Vertex(e, axisZ.unit());
        var polygons = [];
        function point(stack, slice, normalBlend) {
            var angle = slice * Math.PI * 2;
            var out = axisX.times(Math.cos(angle)).plus(axisY.times(Math.sin(angle)));
            var pos = s.plus(ray.times(stack)).plus(out.times(r));
            var normal = out.times(1 - Math.abs(normalBlend)).plus(axisZ.times(normalBlend));
            return new CSG.Vertex(pos, normal);
        }
        for (var i = 0; i < slices; i++) {
            var t0 = i / slices, t1 = (i + 1) / slices;
            polygons.push(new CSG.Polygon([start, point(0, t0, -1), point(0, t1, -1)]));
            polygons.push(new CSG.Polygon([point(0, t1, 0), point(0, t0, 0), point(1, t0, 0), point(1, t1, 0)]));
            polygons.push(new CSG.Polygon([end, point(1, t1, 1), point(1, t0, 1)]));
        }
        return CSG.fromPolygons(polygons);
    };

    /**
    * class Vector<br/>
    * Represents a 3D vector.
    *@example
    *
    *     new CSG.Vector(1, 2, 3);
    *     new CSG.Vector([1, 2, 3]);
    *     new CSG.Vector({ x: 1, y: 2, z: 3 });
    *
    *@memberof Cesium.CSG
    *
    *@param {Number|Array<Number>|Cesium.CSG.Vector}xOrArrayXYZOrVec
    *@param {Number}[y]
    *@param {Number}[z]
    *
    *@property {Number}x
    *@property {Number}y
    *@property {Number}z
    *
    *@constructor
    */
    CSG.Vector = function (x, y, z) {
        if (arguments.length == 3) {
            this.x = x;
            this.y = y;
            this.z = z;
        } else if ('x' in x) {
            this.x = x.x;
            this.y = x.y;
            this.z = x.z;
        } else {
            this.x = x[0];
            this.y = x[1];
            this.z = x[2];
        }
    };

    CSG.Vector.prototype = {
        /**
        *@return {Cesium.CSG.Vector}
        */
        clone: function () {
            return new CSG.Vector(this.x, this.y, this.z);
        },

        /**
        *@return {Cesium.CSG.Vector}
        */
        negated: function () {
            return new CSG.Vector(-this.x, -this.y, -this.z);
        },

        /**
        *@param {Cesium.CSG.Vector}a
        *@return {Cesium.CSG.Vector}
        */
        plus: function (a) {
            return new CSG.Vector(this.x + a.x, this.y + a.y, this.z + a.z);
        },

        /**
        *@param {Cesium.CSG.Vector}a
        *@return {Cesium.CSG.Vector}
        */
        minus: function (a) {
            return new CSG.Vector(this.x - a.x, this.y - a.y, this.z - a.z);
        },

        /**
        *@param {Number}a
        *@return {Cesium.CSG.Vector}
        */
        times: function (a) {
            return new CSG.Vector(this.x * a, this.y * a, this.z * a);
        },

        /**
        *@param {Number}a
        *@return {Cesium.CSG.Vector}
        */
        dividedBy: function (a) {
            return new CSG.Vector(this.x / a, this.y / a, this.z / a);
        },

        /**
        *@param {Cesium.CSG.Vector}a
        *@return {Cesium.CSG.Vector}
        */
        dot: function (a) {
            return this.x * a.x + this.y * a.y + this.z * a.z;
        },

        /**
        *@param {Cesium.CSG.Vector}a
        *@param {Number}t
        *@return {Cesium.CSG.Vector}
        */
        lerp: function (a, t) {
            return this.plus(a.minus(this).times(t));
        },

        /**
        *@return {Number}
        */
        length: function () {
            return Math.sqrt(this.dot(this));
        },

        /**
        *@return {Cesium.CSG.Vector}
        */
        unit: function () {
            return this.dividedBy(this.length());
        },

        /**
        *@param {Cesium.CSG.Vector}a
        *@return {Cesium.CSG.Vector}
        */
        cross: function (a) {
            return new CSG.Vector(
              this.y * a.z - this.z * a.y,
              this.z * a.x - this.x * a.z,
              this.x * a.y - this.y * a.x
            );
        }
    };

    /**
    * class Vertex<br/>
    *<br/>
    * Represents a vertex of a polygon. Use your own vertex class instead of this<br/>
    * one to provide additional features like texture coordinates and vertex<br/>
    * colors. Custom vertex classes need to provide a `pos` property and `clone()`,<br/>
    * `flip()`, and `interpolate()` methods that behave analogous to the ones<br/>
    * defined by `CSG.Vertex`. This class provides `normal` so convenience<br/>
    * functions like `CSG.sphere()` can return a smooth vertex normal, but `normal`<br/>
    * is not used anywhere else.<br/>
    *
    *@memberof Cesium.CSG
    *@param {Array<Number>|Cesium.CSG.Vector}pos
    *@param {Array<Number>|Cesium.CSG.Vector}normal
    *
    *@property {Cesium.CSG.Vector}pos
    *@property {Cesium.CSG.Vector}normal
    *
    *@constructor
    */
    CSG.Vertex = function (pos, normal) {
        this.pos = new CSG.Vector(pos);
        this.normal = new CSG.Vector(normal);
    };

    CSG.Vertex.prototype = {
        /**
        *@return {Cesium.CSG.Vertex}
        */
        clone: function () {
            return new CSG.Vertex(this.pos.clone(), this.normal.clone());
        },
        /**
        * Invert all orientation-specific data (e.g. vertex normal). Called when the<br/>
        * orientation of a polygon is flipped.
        *
        */
        flip: function () {
            this.normal = this.normal.negated();
        },

        /**
        * Create a new vertex between this vertex and `other` by linearly<br/>
        * interpolating all properties using a parameter of `t`. Subclasses should<br/>
        * override this to interpolate additional properties.
        *
        *@param {Cesium.CSG.Vertex}
        *@param {Number}
        *@return {Cesium.CSG.Vertex}
        */
        interpolate: function (other, t) {
            return new CSG.Vertex(
              this.pos.lerp(other.pos, t),
              this.normal.lerp(other.normal, t)
            );
        }
    };

    /**
    * class Plane</br/>
    *
    * Represents a plane in 3D space.
    *
    *@memberof Cesium.CSG
    *@param {Array<Number>|Cesium.CSG.Vector}normal
    *@param {Number}w
    *
    *@property {Cesium.CSG.Vector}normal
    *@property {Number}w
    *
    *@constructor
    */
    CSG.Plane = function (normal, w) {
        this.normal = normal;
        this.w = w;
    };
    /**
    * `CSG.Plane.EPSILON` is the tolerance used by `splitPolygon()` to decide if a</br/>
    * point is on the plane.
    */
    CSG.Plane.EPSILON = 1e-5;

    /**
    *
    *
    *@param {Cesium.CSG.Vector}a
    *@param {Cesium.CSG.Vector}b
    *@param {Cesium.CSG.Vector}c
    */
    CSG.Plane.fromPoints = function (a, b, c) {
        var n = b.minus(a).cross(c.minus(a)).unit();
        return new CSG.Plane(n, n.dot(a));
    };

    CSG.Plane.prototype = {
        /**
        *@return {Cesium.CSG.Plane}
        */
        clone: function () {
            return new CSG.Plane(this.normal.clone(), this.w);
        },

        /**
        *
        */
        flip: function () {
            this.normal = this.normal.negated();
            this.w = -this.w;
        },

        /**
        * Split `polygon` by this plane if needed, then put the polygon or polygon<br/>
        * fragments in the appropriate lists. Coplanar polygons go into either<br/>
        * `coplanarFront` or `coplanarBack` depending on their orientation with<br/>
        * respect to this plane. Polygons in front or in back of this plane go into<br/>
        * either `front` or `back`.
        *
        *@param {Cesium.CSG.Polygon}polygon
        *@param {Array<Cesium.CSG.Polygon>}coplanarFront
        *@param {Array<Cesium.CSG.Polygon>}coplanarBack
        *@param {Array<Cesium.CSG.Polygon>}front
        *@param {Array<Cesium.CSG.Polygon>}back
        */
        splitPolygon: function (polygon, coplanarFront, coplanarBack, front, back) {
            var COPLANAR = 0;
            var FRONT = 1;
            var BACK = 2;
            var SPANNING = 3;

            // Classify each point as well as the entire polygon into one of the above
            // four classes.
            var polygonType = 0;
            var types = [];
            for (var i = 0; i < polygon.vertices.length; i++) {
                var t = this.normal.dot(polygon.vertices[i].pos) - this.w;
                var type = (t < -CSG.Plane.EPSILON) ? BACK : (t > CSG.Plane.EPSILON) ? FRONT : COPLANAR;
                polygonType |= type;
                types.push(type);
            }

            // Put the polygon in the correct list, splitting it when necessary.
            switch (polygonType) {
                case COPLANAR:
                    (this.normal.dot(polygon.plane.normal) > 0 ? coplanarFront : coplanarBack).push(polygon);
                    break;
                case FRONT:
                    front.push(polygon);
                    break;
                case BACK:
                    back.push(polygon);
                    break;
                case SPANNING:
                    var f = [], b = [];
                    for (var i = 0; i < polygon.vertices.length; i++) {
                        var j = (i + 1) % polygon.vertices.length;
                        var ti = types[i], tj = types[j];
                        var vi = polygon.vertices[i], vj = polygon.vertices[j];
                        if (ti != BACK) f.push(vi);
                        if (ti != FRONT) b.push(ti != BACK ? vi.clone() : vi);
                        if ((ti | tj) == SPANNING) {
                            var t = (this.w - this.normal.dot(vi.pos)) / this.normal.dot(vj.pos.minus(vi.pos));
                            var v = vi.interpolate(vj, t);
                            f.push(v);
                            b.push(v.clone());
                        }
                    }
                    if (f.length >= 3) front.push(new CSG.Polygon(f, polygon.shared));
                    if (b.length >= 3) back.push(new CSG.Polygon(b, polygon.shared));
                    break;
            }
        }
    };

    /**
    * class Polygon<br/>
    *<br/>
    * Represents a convex polygon. The vertices used to initialize a polygon must<br/>
    * be coplanar and form a convex loop. They do not have to be `CSG.Vertex`<br/>
    * instances but they must behave similarly (duck typing can be used for<br/>
    * customization).<br/>
    * <br/>
    * Each convex polygon has a `shared` property, which is shared between all<br/>
    * polygons that are clones of each other or were split from the same polygon.<br/>
    * This can be used to define per-polygon properties (such as surface color).<br/>
    *
    *@memberof Cesium.CSG
    *@param {Array<Cesium.CSG.Vertex>}vertices
    *@param {Boolean}shared
    *
    *@property {Array<Cesium.CSG.Vertex>}vertices
    *@property {Boolean}shared
    *@property {Cesium.CSG.Plane}plane
    *@constructor
    */
    CSG.Polygon = function (vertices, shared) {
        this.vertices = vertices;
        this.shared = shared;
        this.plane = CSG.Plane.fromPoints(vertices[0].pos, vertices[1].pos, vertices[2].pos);
    };

    CSG.Polygon.prototype = {
        /**
        *@return {Cesium.CSG.Polygon}
        */
        clone: function () {
            var vertices = this.vertices.map(function (v) { return v.clone(); });
            return new CSG.Polygon(vertices, this.shared);
        },

        /**
        *
        */
        flip: function () {
            this.vertices.reverse().map(function (v) { v.flip(); });
            this.plane.flip();
        }
    };

    /**
    *
    * class Node<br/>
    *<br/>
    * Holds a node in a BSP tree. A BSP tree is built from a collection of polygons<br/>
    * by picking a polygon to split along. That polygon (and all other coplanar<br/>
    * polygons) are added directly to that node and the other polygons are added to<br/>
    * the front and/or back subtrees. This is not a leafy BSP tree since there is<br/>
    * no distinction between internal and leaf nodes.<br/>
    *
    *@memberof Cesium.CSG
    *@param {Array<Cesium.CSG.Polygon>}polygons
    *
    *@property {Array<Cesium.CSG.Polygon>}polygons
    *@property {Cesium.CSG.Plane}plane
    *@property {Cesium.CSG.Plane}front
    *@property {Cesium.CSG.Plane}back
    *@constructor
    */
    CSG.Node = function (polygons) {
        this.plane = null;
        this.front = null;
        this.back = null;
        this.polygons = [];
        if (polygons) this.build(polygons);
    };

    CSG.Node.prototype = {
        /**
        *@return {Cesium.CSG.Node}
        */
        clone: function () {
            var node = new CSG.Node();
            node.plane = this.plane && this.plane.clone();
            node.front = this.front && this.front.clone();
            node.back = this.back && this.back.clone();
            node.polygons = this.polygons.map(function (p) { return p.clone(); });
            return node;
        },

        /**
        * Convert solid space to empty space and empty space to solid space.
        */
        invert: function () {
            for (var i = 0; i < this.polygons.length; i++) {
                this.polygons[i].flip();
            }
            this.plane.flip();
            if (this.front) this.front.invert();
            if (this.back) this.back.invert();
            var temp = this.front;
            this.front = this.back;
            this.back = temp;
        },

        /**
        * Recursively remove all polygons in `polygons` that are inside this BSP<br/>
        * tree.
        *@param {Array<Cesium.CSG.Polygon>}polygons
        *@return {Array<Cesium.CSG.Polygon>}
        */
        clipPolygons: function (polygons) {
            if (!this.plane) return polygons.slice();
            var front = [], back = [];
            for (var i = 0; i < polygons.length; i++) {
                this.plane.splitPolygon(polygons[i], front, back, front, back);
            }
            if (this.front) front = this.front.clipPolygons(front);
            if (this.back) back = this.back.clipPolygons(back);
            else back = [];
            return front.concat(back);
        },

        /**
        * Remove all polygons in this BSP tree that are inside the other BSP tree<br/>
        * `bsp`.
        */
        clipTo: function (bsp) {
            this.polygons = bsp.clipPolygons(this.polygons);
            if (this.front) this.front.clipTo(bsp);
            if (this.back) this.back.clipTo(bsp);
        },

        /**
        * Return a list of all polygons in this BSP tree.
        *@return {Array<Cesium.CSG.Polygon>}
        */
        allPolygons: function () {
            var polygons = this.polygons.slice();
            if (this.front) polygons = polygons.concat(this.front.allPolygons());
            if (this.back) polygons = polygons.concat(this.back.allPolygons());
            return polygons;
        },

        /**
        * Build a BSP tree out of `polygons`. When called on an existing tree, the<br/>
        * new polygons are filtered down to the bottom of the tree and become new<br/>
        * nodes there. Each set of polygons is partitioned using the first polygon<br/>
        * (no heuristic is used to pick a good split).<br/>
        */
        build: function (polygons) {
            if (!polygons.length) return;
            if (!this.plane) this.plane = polygons[0].plane.clone();
            var front = [], back = [];
            for (var i = 0; i < polygons.length; i++) {
                this.plane.splitPolygon(polygons[i], this.polygons, this.polygons, front, back);
            }
            if (front.length) {
                if (!this.front) this.front = new CSG.Node();
                this.front.build(front);
            }
            if (back.length) {
                if (!this.back) this.back = new CSG.Node();
                this.back.build(back);
            }
        }
    };

    /**
    *@param {Cesium.Geometry}
    *@param {Cesium.Cartesian3}[offset]
    *@return {CSG}
    */
    CSG.toCSG = function (geometry, offset) {
        if (!offset) {
            offset = { x: 0, y: 0, z: 0 };
        }
        if (!geometry.attributes.normal) {
            geometry = Cesium.GeometryPipeline.computeNormal(geometry);
        }
        if (geometry.primitiveType !== Cesium.PrimitiveType.TRIANGLES) {
            throw new Error("暂不支持此类几何体");
        }
        if (!CSG) {
            throw new Error('CSG 库未加载。请从 https://github.com/evanw/csg.js 获取');
        }
        var faceCount = geometry.indices.length / 3;
        var polygons = [], vertices = [];
        var positions = geometry.attributes.position.values;
        var normals = geometry.attributes.normal.values;
        var normalIdx = 0, positionIdx = 0;

        for (var i = 0; i < geometry.indices.length  ; i += 3) {
            vertices = [];

            var idx1 = geometry.indices[i];
            var idx2 = geometry.indices[i + 1];
            var idx3 = geometry.indices[i + 2];

            positionIdx = idx1 * 3;
            normalIdx = idx1 * 3;

            vertices.push(new CSG.Vertex(
                 [positions[positionIdx++] + offset.x, positions[positionIdx++] + offset.y, positions[positionIdx++] + offset.z],
                 [normals[normalIdx++], normals[normalIdx++], normals[normalIdx++]]
                ));

            positionIdx = idx2 * 3;
            normalIdx = idx2 * 3;
            vertices.push(new CSG.Vertex(
                [positions[positionIdx++] + offset.x, positions[positionIdx++] + offset.y, positions[positionIdx++] + offset.z],
                [normals[normalIdx++], normals[normalIdx++], normals[normalIdx++]]
               ));

            positionIdx = idx3 * 3;
            normalIdx = idx3 * 3;
            vertices.push(new CSG.Vertex(
                [positions[positionIdx++] + offset.x, positions[positionIdx++] + offset.y, positions[positionIdx++] + offset.z],
                [normals[normalIdx++], normals[normalIdx++], normals[normalIdx++]]
               ));
            polygons.push(new CSG.Polygon(vertices));
        }
        return CSG.fromPolygons(polygons);
    }
    /**
    *@param {CSG}csg_model
    *@return {Cesium.Geometry}
    */
    CSG.fromCSG = function (csg_model) {
        var i, j, vertices,
			polygons = csg_model.toPolygons();

        if (!CSG) {
            throw new Error('CSG 库未加载。请从 https://github.com/evanw/csg.js 获取');
        }

        var positions = [];
        var normals = [];
        var indices = [];

        for (i = 0; i < polygons.length; i++) {

            // Vertices
            vertices = [];
            for (j = 0; j < polygons[i].vertices.length; j++) {
                vertices.push(this.getGeometryVertice(positions, normals, polygons[i].vertices[j].pos, polygons[i].plane.normal));
            }
            if (vertices[0] === vertices[vertices.length - 1]) {
                vertices.pop();
            }

            for (var j = 2; j < vertices.length; j++) {
                indices.push(vertices[0], vertices[j - 1], vertices[j]);
            }
        }

        positions = new Float32Array(positions);
        normals = new Float32Array(normals);

        indices = new Int32Array(indices);
        var attributes = {};
        attributes.position = new Cesium.GeometryAttribute({
            componentDatatype: Cesium.ComponentDatatype.FLOAT,
            componentsPerAttribute: 3,
            values: positions
        });
        attributes.normal = new Cesium.GeometryAttribute({
            componentDatatype: Cesium.ComponentDatatype.FLOAT,
            componentsPerAttribute: 3,
            values: normals
        });

        var cesGeometry = new Cesium.Geometry({
            attributes: attributes,
            indices: indices,
            primitiveType: Cesium.PrimitiveType.TRIANGLES
        });

        return cesGeometry;
    },
    /**
    *@param {Array<Number>}positions
    *@param {Array<Number>}normals
    *@param {Cesium.CSG.Vector}vertice_position
    *@param {Cesium.CSG.Vector}plane_normal
    *@return {Number}
    *@private
    */
    CSG.getGeometryVertice = function (positions, normals, vertice_position, plane_normal) {
        var i, idx = 0;
        for (i = 0; i < positions.length; i += 3) {
            if (positions[i] === vertice_position.x
                && positions[i + 1] === vertice_position.y
                && positions[i + 2] === vertice_position.z) {
                // Vertice already exists
                return idx;
            }
            idx++;
        };

        positions.push(vertice_position.x, vertice_position.y, vertice_position.z);
        normals.push(plane_normal.x, plane_normal.y, plane_normal.z);
        return idx;
    }

    return CSG;
});
define('Util/defineProperty',[],function () {

    /**
    *定义属性，并监听属性变化事件,属性值的数据类型可以实现equals接口用于进行更进一步的比较
    *@param {Object}owner
    *@param {String}name
    *@param {Any}defaultVal
    *@param {Function}onChanged
    *@memberof Cesium
    */
    function defineProperty(owner, name, defaultVal, onChanged) {
        owner["_" + name] = defaultVal;
        var value = {
            get: function () {
                return this["_" + name];
            },
            set: function (val) {
                var changed = val != this["_" + name];
                if (this["_" + name] && this["_" + name].equals && val) {
                    changed = this["_" + name].equals(val);
                }
                this["_" + name] = val;
                if (typeof onChanged == 'function' && changed) {
                    onChanged(changed, owner);
                }
            }
        };
        var properties = {};
        properties[name] = value;
        Object.defineProperties(owner, properties)
    }

    return defineProperty;
});
define('Core/MeshMaterial',['Util/defineProperty'], function (defineProperty) {
    var defaultValue = Cesium.defaultValue;
    /**
    *
    *@param {Object}options
    *@param {Object}[options.uniforms]
    *@param {Object}[options.uniformStateUsed]
    *@param {Boolean}[options.translucent]
    *@param {Boolean}[options.wireframe]
    *@param {Enum}[options.side=Cesium.MeshMaterial.Sides.DOUBLE]
    *@param {String|Cesium.Color}[options.defaultColor=Cesium.Color.WHITE]
    *@param {String}[options.vertexShader]
    *@param {String}[options.fragmentShader]
    *
    *
    *@property {Object}uniforms
    *@property {Object}uniformStateUsed
    *@property {Boolean}translucent
    *@property {Boolean}wireframe
    *@property {Enum}side
    *@property {String|Cesium.Color}defaultColor
    *@property {String}vertexShader
    *@property {String}fragmentShader
    *
    *@constructor
    *@memberof Cesium
    */
    function MeshMaterial(options) {
        options = defaultValue(options, {});
        options.uniforms = defaultValue(options.uniforms, {});
        var that = this;

        this._uuid = Cesium.createGuid();

        function initUniform(srcUniforms) {
            var _uniforms = {};

            for (var i in srcUniforms) {
                if (srcUniforms.hasOwnProperty(i) && Cesium.defined(srcUniforms[i])) {
                    var item = srcUniforms[i];

                    var val = {};
                    val.needsUpdate = true;

                    if (Array.isArray(item) && item.length >= 3 && item.length <= 4 && typeof item[0] === 'number') {
                        srcUniforms[i] = new Cesium.Color(srcUniforms[i][0], srcUniforms[i][1], srcUniforms[i][2], srcUniforms[i][3]);
                    } else if (Cesium.defined(item.value)) {
                        for (var n in item) {
                            if (item.hasOwnProperty(n)) {
                                val[n] = item[n];
                            }
                        }
                    }

                    if (srcUniforms[i].hasOwnProperty("uuid")) {
                        defineProperty(val, "uuid", srcUniforms[i].uuid, function (changed, owner) {
                            owner.needsUpdate = changed;
                        });
                    } else {
                        defineProperty(val, "uuid", Cesium.createGuid(), function (changed, owner) {
                            owner.needsUpdate = changed;
                        });
                    }
                    if (srcUniforms[i].hasOwnProperty("value")) {
                        defineProperty(val, "value", srcUniforms[i].value, function (changed, owner) {
                            owner.needsUpdate = changed;
                        });
                    } else {
                        defineProperty(val, "value", srcUniforms[i], function (changed, owner) {
                            owner.needsUpdate = changed;
                        });
                    }
                    _uniforms[i] = val;
                    //defineProperty(_uniforms, i, val, function (changed) {
                    //    that.needsUpdate = changed;
                    //});
                }
            }
            return _uniforms;
        }
        this._defaultColor = defaultValue(options.defaultColor, Cesium.Color.WHITE);
        if (typeof this._defaultColor == 'string') {
            this._defaultColor = Cesium.Color.fromCssColorString(this._defaultColor);
        }

        this._pickedColor = defaultValue(options.pickedColor, Cesium.Color.YELLOW);
        if (typeof this._pickedColor == 'string') {
            this._pickedColor = Cesium.Color.fromCssColorString(this._pickedColor);
        }
        this._picked = defaultValue(options.picked, 0);
        options.uniforms.pickedColor = this._pickedColor;
        options.uniforms.defaultColor = this._defaultColor;
        options.uniforms.picked = this._picked;

        this._uniforms = initUniform(options.uniforms);

        function onPropertyChanged(changed) {
            that.needsUpdate = changed;
        }

        defineProperty(this, "translucent", defaultValue(options.translucent, false), onPropertyChanged);
        defineProperty(this, "wireframe", defaultValue(options.wireframe, false), onPropertyChanged);
        defineProperty(this, "side", defaultValue(options.side, MeshMaterial.Sides.DOUBLE), onPropertyChanged);

        defineProperty(this, "uniformStateUsed", defaultValue(options.uniformStateUsed, [{
            uniformStateName: "model",
            glslVarName: "modelMatrix"
        }]), onPropertyChanged);
        defineProperty(this, "uniforms", this._uniforms, function () {
            that._uniforms = initUniform(that._uniforms);
        });


        this._vertexShader = '//#inner\n void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\n}';
        this._fragmentShader = '//#inner' + this._uuid + '\n uniform float picked;\n uniform vec4  pickedColor;\n uniform vec4  defaultColor;\n void main() {\ngl_FragColor = defaultColor;\n if(picked!=0.0){\ngl_FragColor = pickedColor;}}';// vec4( ' + this._defaultColor.red + ',' + this._defaultColor.green + ',' + this._defaultColor.blue + ',' + this._defaultColor.alpha + ');\n}';

        defineProperty(this, "vertexShader", defaultValue(options.vertexShader, this._vertexShader), onPropertyChanged);
        defineProperty(this, "fragmentShader", defaultValue(options.fragmentShader, this._fragmentShader), onPropertyChanged);

        this.depthTest =defaultValue(options.depthTest, true);
        this.depthMask = defaultValue(options.depthMask, true);
        this.blending = defaultValue(options.blending, true);

        this.needsUpdate = true;
    }


    Object.defineProperties(MeshMaterial.prototype, {
        uuid: {
            get: function () {
                return this._uuid;
            }
        },
        defaultColor: {
            set: function (val) {
                if (typeof val == 'string') {
                    val = Cesium.Color.fromCssColorString(val);
                }
                Cesium.Color.clone(val, this._defaultColor);
            },
            get: function () {
                return this._defaultColor;
            }
        }
    });

    /**
   *
   *@memberof Cesium.MeshMaterial
   *@property {Enum}FRONT
   *@property {Enum}BACK
   *@property {Enum}DOUBLE
   */
    MeshMaterial.Sides = {
        FRONT: 3,
        BACK: 1,
        DOUBLE: 2
    }
    return MeshMaterial;
});
define('Core/GeometryUtils',[
    'Util/CSG'
], function (CSG) {

    /**
    *
    *@constructor
    *@memberof Cesium
    */
    function GeometryUtils() {

    }

    function getAttrs(geo) {
        var attrNames = [];

        for (var name in geo.attributes) {
            if (geo.attributes.hasOwnProperty(name) && geo.attributes[name]) {
                attrNames.push(name);
            }
        }
        return attrNames
    }

    var scratchPosition = new Cesium.Cartesian3();
    var scratchQuaternion = new Cesium.Quaternion();
    var scratchMatrix4 = new Cesium.Matrix4();
    var scratchRotation = new Cesium.Matrix3();

    /**
    *绕x轴旋转，修改顶点坐标
    *@param {Cesium.Geometry}geometry
    *@param {Number}angle 弧度
    */
    GeometryUtils.rotateX = function (geometry, angle) {

        var positions = geometry.attributes.position.values;

        Cesium.Matrix3.fromRotationX(angle, scratchRotation);
        Cesium.Matrix4.fromRotationTranslation(scratchRotation, Cesium.Cartesian3.ZERO, scratchMatrix4);

        for (var i = 0; i < positions.length; i += 3) {
            scratchPosition.x = positions[i];
            scratchPosition.y = positions[i + 1];
            scratchPosition.z = positions[i + 2];
            Cesium.Matrix4.multiplyByPoint(scratchMatrix4, scratchPosition, scratchPosition);
            positions[i] = scratchPosition.x;
            positions[i + 1] = scratchPosition.y;
            positions[i + 2] = scratchPosition.z;
        }

    }
    /**
    *绕y轴旋转，修改顶点坐标
    *@param {Cesium.Geometry}geometry
    *@param {Number}angle 弧度
    */
    GeometryUtils.rotateY = function (geometry, angle) {

        var positions = geometry.attributes.position.values;

        Cesium.Matrix3.fromRotationY(angle, scratchRotation);
        Cesium.Matrix4.fromRotationTranslation(scratchRotation, Cesium.Cartesian3.ZERO, scratchMatrix4);

        for (var i = 0; i < positions.length; i += 3) {
            scratchPosition.x = positions[i];
            scratchPosition.y = positions[i + 1];
            scratchPosition.z = positions[i + 2];
            Cesium.Matrix4.multiplyByPoint(scratchMatrix4, scratchPosition, scratchPosition);
            positions[i] = scratchPosition.x;
            positions[i + 1] = scratchPosition.y;
            positions[i + 2] = scratchPosition.z;
        }

    }

    /**
    *绕z轴旋转，修改顶点坐标
    *@param {Cesium.Geometry}geometry
    *@param {Number}angle 弧度
    */
    GeometryUtils.rotateZ = function (geometry, angle) {

        var positions = geometry.attributes.position.values;

        Cesium.Matrix3.fromRotationZ(angle, scratchRotation);
        Cesium.Matrix4.fromRotationTranslation(scratchRotation, Cesium.Cartesian3.ZERO, scratchMatrix4);

        for (var i = 0; i < positions.length; i += 3) {
            scratchPosition.x = positions[i];
            scratchPosition.y = positions[i + 1];
            scratchPosition.z = positions[i + 2];
            Cesium.Matrix4.multiplyByPoint(scratchMatrix4, scratchPosition, scratchPosition);
            positions[i] = scratchPosition.x;
            positions[i + 1] = scratchPosition.y;
            positions[i + 2] = scratchPosition.z;
        }

    }
    /**
    *
    *@param {Cesium.Geometry}geometry
    */
    GeometryUtils.computeVertexNormals = function (geometry) {

        var indices = geometry.indices;
        var attributes = geometry.attributes;
        var il = indices.length;
        if (attributes.position) {

            var positions = attributes.position.values;

            if (attributes.normal === undefined) {
                attributes.normal = new Cesium.GeometryAttribute({
                    componentDatatype: Cesium.ComponentDatatype.FLOAT,
                    componentsPerAttribute: 3,
                    values: new Float32Array(positions.length)
                })

            } else {

                // reset existing normals to zero

                var array = attributes.normal.values;

                for (var i = 0; i < il; i++) {

                    array[i] = 0;

                }

            }

            var normals = attributes.normal.values;

            var vA, vB, vC;

            var pA = new Cesium.Cartesian3(), pB = new Cesium.Cartesian3(), pC = new Cesium.Cartesian3();
            var cb = new Cesium.Cartesian3(), ab = new Cesium.Cartesian3();

            for (var i = 0; i < il; i += 3) {

                vA = indices[i + 0] * 3;
                vB = indices[i + 1] * 3;
                vC = indices[i + 2] * 3;

                Cesium.Cartesian3.fromArray(positions, vA, pA);
                Cesium.Cartesian3.fromArray(positions, vB, pB);
                Cesium.Cartesian3.fromArray(positions, vC, pC);

                Cesium.Cartesian3.subtract(pC, pB, cb);
                Cesium.Cartesian3.subtract(pA, pB, ab);
                Cesium.Cartesian3.cross(cb, ab, cb);

                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;

            }

            normalizeNormals(geometry);

            attributes.normal.needsUpdate = true;

        }

        return geometry;
    }
    function normalizeNormals(geometry) {

        var normals = geometry.attributes.normal.values;

        var x, y, z, n;

        for (var i = 0; i < normals.length; 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] = x * n;
            normals[i + 1] = y * n;
            normals[i + 2] = z * n;
        }

    }

    /**
    *合并两个或两个以上图形类型（primitiveType），属性数量、名称以及属性值的类型（GeometryAttribute的componentDatatype、componentsPerAttribute等）都一致的几何体
    *@param {Array<Cesium.Geometry>}geometries
    *@return {Cesium.Geometry}
    */
    GeometryUtils.mergeGeometries = function (geometries) {
        if (!geometries || !geometries.length) {
            throw new Error("缺少geometries参数");
        }

        if (geometries.length == 1) {
            return geometries[0];
        }
        var geometriesAttrs = [];

        var lengthChanged = false;
        var primitiveTypeChanged = false;
        var primitiveType = geometries[0].primitiveType;
        for (var i = 0; i < geometries.length; i++) {

            geometriesAttrs[i] = getAttrs(geometries[i]);
            if (i > 0) {
                if (primitiveType != geometries[i].primitiveType) {
                    primitiveTypeChanged = true;
                    break;
                }
                var lastGeoAttrs = geometriesAttrs[i - 1];
                lengthChanged = lastGeoAttrs.length != geometriesAttrs[i].length;
                if (!lengthChanged) {

                    for (var j = 0; j < lastGeoAttrs.length; j++) {
                        if (lastGeoAttrs[j] != geometriesAttrs[i][j]) {
                            lengthChanged = true;
                            break;
                        }

                    }
                }
            }
            primitiveType = geometries[i].primitiveType;
            if (lengthChanged || primitiveTypeChanged) {
                break;
            }
        }
        if (primitiveTypeChanged) {
            throw new Error("待合并的几何体中primitiveType属性不完全一致");
        }
        if (lengthChanged) {
            throw new Error("待合并的几何体中属性数量和和名称不完全一致");
        }
        var newAttrs = {};
        var attrNames = geometriesAttrs[0];
        for (var i = 0; i < attrNames.length; i++) {
            var attrName = attrNames[i];
            var geometry = geometries[0];
            newAttrs[attrName] = {};
            //newAttrs[attrName] = Cesium.clone(geometry.attributes[attrName]);
            for (var n in geometry.attributes[attrName]) {
                if (geometry.attributes[attrName].hasOwnProperty(n)) {
                    newAttrs[attrName][n] = geometry.attributes[attrName][n];
                }
            }
            var values = Array.from(newAttrs[attrName].values);

            for (var j = 1; j < geometries.length; j++) {
                geometry = geometries[j];
                for (var vi = 0; vi < geometry.attributes[attrName].values.length; vi++) {
                    values.push(geometry.attributes[attrName].values[vi]);
                }
            }

            newAttrs[attrName].values = new newAttrs[attrName].values.constructor(values);
        }
        var indices = [];
        var currIndex = 0;
        for (var j = 0; j < geometries.length; j++) {
            var geometry = geometries[0];
            for (var i = 0; i < geometry.indices.length; i++) {
                indices.push(geometry.indices[i] + currIndex);
            }
            currIndex += geometry.attributes.position.values.length / 3;
        }

        var bs = Cesium.BoundingSphere.fromVertices(newAttrs.position.values);
        var geo = new Cesium.Geometry({
            attributes: newAttrs,
            indices: new Int32Array(indices),
            primitiveType: geometries[0].primitiveType,
            boundingSphere: bs
        });
        return geo;
    }
    var scratchOffset = new Cesium.Cartesian3();
    /**
    *
    *@param {Cesium.Geometry}geometry
    *@param {Cesium.Cartesian3}offset
    */
    GeometryUtils.translate = function (geometry, offset) {
        if (Array.isArray(offset)) {
            scratchOffset.x = offset[0];
            scratchOffset.y = offset[1];
            scratchOffset.z = offset[2];
        } else {
            Cesium.Cartesian3.clone(offset, scratchOffset);
        }

        for (var i = 0; i < geometry.attributes.position.values.length; i += 3) {
            geometry.attributes.position.values[i] += scratchOffset.x;
            geometry.attributes.position.values[i + 1] += scratchOffset.y;
            geometry.attributes.position.values[i + 2] += scratchOffset.z;
        }
        //if (geometry.attributes.normal) {
        //    Cesium.GeometryPipeline.computeNormal(geometry);
        //}
    }

    /**
    *
    *@param {TypeArray} array
    *@return {Cesium.ComponentDatatype}
    */
    GeometryUtils.getAttributeComponentType = function (array) {

        var attributeComponentType = Cesium.ComponentDatatype.SHORT;
        if (array instanceof Int8Array) {
            attributeComponentType = Cesium.ComponentDatatype.BYTE;

        } else if (array instanceof Uint8Array || array instanceof Uint8ClampedArray) {
            attributeComponentType = Cesium.ComponentDatatype.UNSIGNED_BYTE;

        } else if (array instanceof Int16Array) {
            attributeComponentType = Cesium.ComponentDatatype.SHORT;

        } else if (array instanceof Uint16Array) {
            attributeComponentType = Cesium.ComponentDatatype.UNSIGNED_SHORT;

        } else if (array instanceof Int32Array) {
            attributeComponentType = Cesium.ComponentDatatype.INT;

        } else if (array instanceof Uint32Array) {
            attributeComponentType = Cesium.ComponentDatatype.UNSIGNED_INT;

        } else if (array instanceof Float32Array) {
            attributeComponentType = Cesium.ComponentDatatype.FLOAT;

        } else if (array instanceof Float64Array) {
            attributeComponentType = Cesium.ComponentDatatype.DOUBLE;

        }

        return attributeComponentType;

    }

    /**
    *
    *@param {Object}geometry
    *@return {Boolean}
    */
    GeometryUtils.isGeometry3js = function (geometry) {
        return (typeof THREE !== 'undefined' && (geometry instanceof THREE.Geometry || geometry instanceof THREE.BufferGeometry))
            || (geometry.attributes && geometry.attributes.position && geometry.index)
            || (geometry.vertices && geometry.faces);
    }

    /**
     *
     *@param {THREE.BufferGeometry}geometry
     *@private
     */
    GeometryUtils.parseBufferGeometry3js = function (geometry) {
        // var start = new Date();

        var attributes = {};
        if (!geometry.attributes.normal) {
            geometry.computeFaceNormals();
        }
        for (var attrName in geometry.attributes) {

            if (geometry.attributes.hasOwnProperty(attrName)) {
                var attr = geometry.getAttribute(attrName);
                if (attr && attr.array.length > 0) {

                    attributes[attrName] = new Cesium.GeometryAttribute({
                        componentDatatype: GeometryUtils.getAttributeComponentType(attr.array),
                        componentsPerAttribute: attr.itemSize,
                        values: attr.array,
                        normalize: attr.normalized
                    });

                }

            }
        }
        var indices = [];
        if (!geometry.index && geometry.groups) {
            geometry.groups.forEach(function (group) {
                for (var i = 0; i < group.count; i++) {
                    indices.push(i + group.start);
                }
            })
            indices = new Int32Array(indices);
        } else {
            indices = geometry.index.array;
        }
        var cesGeometry = new Cesium.Geometry({
            attributes: attributes,
            indices: indices,
            primitiveType: Cesium.PrimitiveType.TRIANGLES
        });

        return cesGeometry;
    }

    /**
    *
    *@param {THREE.Geometry}geometry3js
    *@return {Cesium.Geometry}
    */
    GeometryUtils.fromGeometry3js = function (geometry3js) {

        if (geometry3js.attributes && (geometry3js.index || geometry3js.groups.length)) {

        } else {
            geometry3js = new THREE.BufferGeometry().fromGeometry(geometry3js);
        }
        var geometry = GeometryUtils.parseBufferGeometry3js(geometry3js);
        //GeometryUtils.computeVertexNormals(geometry);
        Cesium.GeometryPipeline.computeNormal(geometry);
        return geometry;
        var positions = new Float32Array(geometry3js.vertices.length * 3);
        for (var i = 0; i < geometry3js.vertices.length; i++) {
            positions[i * 3] = geometry3js.vertices[i].x;
            if (!geometry3js.up || geometry3js.up.y) {
                positions[i * 3 + 1] = geometry3js.vertices[i].z;
                positions[i * 3 + 2] = geometry3js.vertices[i].y;
            } else {
                positions[i * 3 + 1] = geometry3js.vertices[i].y;
                positions[i * 3 + 2] = geometry3js.vertices[i].z;
            }
        }
        var indices = new Int32Array(geometry3js.faces.length * 3);
        for (var i = 0; i < geometry3js.faces.length; i++) {
            indices[i * 3] = geometry3js.faces[i].a;
            indices[i * 3 + 1] = geometry3js.faces[i].b;
            indices[i * 3 + 2] = geometry3js.faces[i].c;
        }
        var attributes = {};
        attributes.position = new Cesium.GeometryAttribute({
            componentDatatype: Cesium.ComponentDatatype.FLOAT,
            componentsPerAttribute: 3,
            values: positions
        });
        var cesGeometry = new Cesium.Geometry({
            attributes: attributes,
            indices: indices,
            primitiveType: Cesium.PrimitiveType.TRIANGLES
        });
        return cesGeometry;
    }
    /**
    *
    *@param {Cesium.Geometry}geometry
    *@return {THREE.Geometry}
    */
    GeometryUtils.toGeometry3js = function (geometry) {
        if (typeof THREE === 'undefined') {
            throw new Error("THREE 未加载");
        }

        var positions = geometry.attributes.position.values;
        var positionIdx = 0;

        var geometry3js = new THREE.Geometry();

        for (var i = 0; i < positions.length  ; i += 3) {
            positionIdx = i * 3;
            geometry3js.vertices.push(
                 new THREE.Vector3(positions[positionIdx], positions[positionIdx + 2], positions[positionIdx + 1])
             );
        }

        for (var i = 0; i < geometry.indices.length  ; i += 3) {
            var idx1 = geometry.indices[i];
            var idx2 = geometry.indices[i + 1];
            var idx3 = geometry.indices[i + 2];
            geometry3js.faces.push(new THREE.Face3(idx1, idx2, idx3));
        }

        return geometry3js;
    }

    /**
   *@param {Cesium.Geometry|THREE.Geometry}
   *@param {Cesium.Cartesian3}[offset]
   *@return {CSG}
   */
    GeometryUtils.toCSG = function (geometry, offset) {
        if (!(typeof THREE === 'undefined')) {
            if (geometry instanceof THREE.Geometry) {
                return GeometryUtils._toCSG3js(geometry, offset);
            }
        }
        if (!offset) {
            offset = { x: 0, y: 0, z: 0 };
        }
        if (!geometry.attributes.normal) {
            geometry = Cesium.GeometryPipeline.computeNormal(geometry);
        }
        if (geometry.primitiveType !== Cesium.PrimitiveType.TRIANGLES) {
            throw new Error("暂不支持此类几何体");
        }
        if (!CSG) {
            throw new Error('CSG 库未加载。请从 https://github.com/evanw/csg.js 获取');
        }
        var faceCount = geometry.indices.length / 3;
        var polygons = [], vertices = [];
        var positions = geometry.attributes.position.values;
        var normals = geometry.attributes.normal.values;
        var normalIdx = 0, positionIdx = 0;

        for (var i = 0; i < geometry.indices.length  ; i += 3) {
            vertices = [];

            var idx1 = geometry.indices[i];
            var idx2 = geometry.indices[i + 1];
            var idx3 = geometry.indices[i + 2];

            positionIdx = idx1 * 3;
            normalIdx = idx1 * 3;

            vertices.push(new CSG.Vertex(
                 [positions[positionIdx++] + offset.x, positions[positionIdx++] + offset.y, positions[positionIdx++] + offset.z],
                 [normals[normalIdx++], normals[normalIdx++], normals[normalIdx++]]
                ));

            positionIdx = idx2 * 3;
            normalIdx = idx2 * 3;
            vertices.push(new CSG.Vertex(
                [positions[positionIdx++] + offset.x, positions[positionIdx++] + offset.y, positions[positionIdx++] + offset.z],
                [normals[normalIdx++], normals[normalIdx++], normals[normalIdx++]]
               ));

            positionIdx = idx3 * 3;
            normalIdx = idx3 * 3;
            vertices.push(new CSG.Vertex(
                [positions[positionIdx++] + offset.x, positions[positionIdx++] + offset.y, positions[positionIdx++] + offset.z],
                [normals[normalIdx++], normals[normalIdx++], normals[normalIdx++]]
               ));
            polygons.push(new CSG.Polygon(vertices));
        }
        return CSG.fromPolygons(polygons);
    }
    /**
    *@param {CSG}csg_model
    *@param {Boolean}[toGeometry3js=false]
    *@return {Cesium.Geometry|THREE.Geometry}
    */
    GeometryUtils.fromCSG = function (csg_model, toGeometry3js) {
        if (!(typeof THREE === 'undefined')) {
            if (geometry instanceof THREE.Geometry) {
                return GeometryUtils._fromCSG3js(geometry, offset);
            }
        }
        var i, j, vertices,
			polygons = csg_model.toPolygons();

        if (!CSG) {
            throw new Error('CSG 库未加载。请从 https://github.com/evanw/csg.js 获取');
        }

        var positions = [];
        var normals = [];
        var indices = [];

        for (i = 0; i < polygons.length; i++) {

            // Vertices
            vertices = [];
            for (j = 0; j < polygons[i].vertices.length; j++) {
                vertices.push(this.getGeometryVertice(positions, normals, polygons[i].vertices[j].pos, polygons[i].plane.normal));
            }
            if (vertices[0] === vertices[vertices.length - 1]) {
                vertices.pop();
            }

            for (var j = 2; j < vertices.length; j++) {
                indices.push(vertices[0], vertices[j - 1], vertices[j]);
            }
        }

        positions = new Float32Array(positions);
        normals = new Float32Array(normals);

        indices = new Int32Array(indices);
        var attributes = {};
        attributes.position = new Cesium.GeometryAttribute({
            componentDatatype: Cesium.ComponentDatatype.FLOAT,
            componentsPerAttribute: 3,
            values: positions
        });
        attributes.normal = new Cesium.GeometryAttribute({
            componentDatatype: Cesium.ComponentDatatype.FLOAT,
            componentsPerAttribute: 3,
            values: normals
        });

        var cesGeometry = new Cesium.Geometry({
            attributes: attributes,
            indices: indices,
            primitiveType: Cesium.PrimitiveType.TRIANGLES
        });

        return cesGeometry;
    }

    GeometryUtils._toCSG3js = function (three_model, offset, rotation) {
        if (typeof THREE === 'undefined') {
            throw new Error("THREE 未加载");
        }

        var i, geometry, polygons, vertices, rotation_matrix;

        if (!CSG) {
            throw 'CSG library not loaded. Please get a copy from https://github.com/evanw/csg.js';
        }

        if (three_model instanceof THREE.Mesh) {
            geometry = three_model.geometry;
            offset = offset || three_model.position;
            rotation = rotation || three_model.rotation;
        } else if (three_model instanceof THREE.Geometry) {
            geometry = three_model;
            offset = offset || new THREE.Vector3(0, 0, 0);
            rotation = rotation || new THREE.Euler(0, 0, 0);
        } else {
            throw 'Model type not supported.';
        }
        rotation_matrix = new THREE.Matrix4().makeRotationFromEuler(rotation);

        var polygons = [];
        for (i = 0; i < geometry.faces.length; i++) {
            if (geometry.faces[i] instanceof THREE.Face3) {

                vertices = [];
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].a].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].b].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].c].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                polygons.push(new CSG.Polygon(vertices));

            } else if (geometry.faces[i] instanceof THREE.Face4) {

                vertices = [];
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].a].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].b].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].d].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                polygons.push(new CSG.Polygon(vertices));

                vertices = [];
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].b].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].c].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                vertices.push(new CSG.Vertex(geometry.vertices[geometry.faces[i].d].clone().add(offset).applyMatrix4(rotation_matrix), [geometry.faces[i].normal.x, geometry.faces[i].normal.y, geometry.faces[i].normal.z]));
                polygons.push(new CSG.Polygon(vertices));

            } else {
                throw 'Model contains unsupported face.';
            }
        }

        return CSG.fromPolygons(polygons);
    }

    GeometryUtils._fromCSG3js = function (csg_model) {
        if (typeof THREE === 'undefined') {
            throw new Error("THREE 未加载");
        }
        var i, j, vertices, face,
            three_geometry = new THREE.Geometry(),
            polygons = csg_model.toPolygons();

        if (!CSG) {
            throw 'CSG library not loaded. Please get a copy from https://github.com/evanw/csg.js';
        }

        for (i = 0; i < polygons.length; i++) {

            // Vertices
            vertices = [];
            for (j = 0; j < polygons[i].vertices.length; j++) {
                vertices.push(GeometryUtils._getGeometryVertice3js(three_geometry, polygons[i].vertices[j].pos));
            }
            if (vertices[0] === vertices[vertices.length - 1]) {
                vertices.pop();
            }

            for (var j = 2; j < vertices.length; j++) {
                face = new THREE.Face3(vertices[0], vertices[j - 1], vertices[j], new THREE.Vector3().copy(polygons[i].plane.normal));
                three_geometry.faces.push(face);
                three_geometry.faceVertexUvs[0].push(new THREE.Vector2());
            }
        }

        three_geometry.computeBoundingBox();

        return three_geometry;
    },

    GeometryUtils._getGeometryVertice3js = function (geometry, vertice_position) {
        var i;
        for (i = 0; i < geometry.vertices.length; i++) {
            if (geometry.vertices[i].x === vertice_position.x && geometry.vertices[i].y === vertice_position.y && geometry.vertices[i].z === vertice_position.z) {
                // Vertice already exists
                return i;
            }
        };

        geometry.vertices.push(new THREE.Vector3(vertice_position.x, vertice_position.y, vertice_position.z));
        return geometry.vertices.length - 1;
    }

    return GeometryUtils;
});
define('Core/Shaders/phong_frag',[],function () {
    var phong_frag = '\n\
varying vec3 v_position;\n\
varying vec3 v_normal;\n\
uniform float picked;\n\
uniform vec4  pickedColor;\n\
uniform vec4  defaultColor;\n\
uniform float specular;\n\
uniform float shininess;\n\
uniform vec3  emission;\n\
void main() {\n\
    vec3 positionToEyeEC = -v_position; \n\
    vec3 normalEC =normalize(v_normal);\n\
    vec4 color=defaultColor;\n\
    if(picked!=0.0){\n\
        color = pickedColor;\n\
    }\n\
    czm_material material;\n\
    material.specular = specular;\n\
    material.shininess = shininess;\n\
    material.normal =  normalEC;\n\
    material.emission =emission;//vec3(0.2,0.2,0.2);\n\
    material.diffuse = color.rgb ;\n\
    material.alpha =  color.a;\n\
    gl_FragColor =  czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC);\n\
}';

    return phong_frag;
})
;
define('Core/Shaders/phong_vert',[],function () {
    var phong_vert = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
\n\
\n\
varying vec3 v_position;\n\
varying vec3 v_normal;\n\
\n\
varying vec3 v_light0Direction;\n\
\n\
void main(void) \n\
{\n\
    vec4 pos =  modelViewMatrix * vec4( position,1.0);\n\
    v_normal =  normalMatrix *  normal;\n\
    v_position = pos.xyz;\n\
    v_light0Direction = mat3( modelViewMatrix) * vec3(1.0,1.0,1.0);\n\
    gl_Position =  projectionMatrix * pos;\n\
}";

    return phong_vert;
});
define('Core/MeshPhongMaterial',[
    'Core/MeshMaterial',
    'Core/Shaders/phong_frag',
    'Core/Shaders/phong_vert'
], function (
    MeshMaterial,
    phong_frag,
    phong_vert
    ) {
    /**
    *
    *@constructor
    *@memberof Cesium
    *@extends Cesium.MeshMaterial
    */
    function MeshPhongMaterial(options) {
        options = options ? options : {};

        options.uniforms = options.uniforms ? options.uniforms : {
            shininess: -1,
            emission: [0, 0, 0],
            specular: 0
        };
        options.uniforms.shininess = Cesium.defaultValue(options.uniforms.shininess, 0);
        options.uniforms.emission = Cesium.defaultValue(options.uniforms.emission, [0.2, 0.2, 0.2]);
        options.uniforms.specular = Cesium.defaultValue(options.uniforms.specular, 0);

        MeshMaterial.apply(this, arguments);
        this.vertexShader = phong_vert;
        this.fragmentShader = phong_frag;
    }
    MeshPhongMaterial.prototype = new MeshMaterial();
    return MeshPhongMaterial;
})
;
define('Core/Mesh',[
    'Core/Rotation',
    'Util/CSG',
    'Core/MeshMaterial',
    'Core/GeometryUtils',
    'Core/MeshPhongMaterial'
], function (
    Rotation,
    CSG,
    MeshMaterial,
    GeometryUtils,
    MeshPhongMaterial
    ) {
    var defaultValue = Cesium.defaultValue;
    /**
    *
    *@param {Object|geometry}options
    *@param {Cesium.Geometry|Cesium.CSG|THREE.Geometry|THREE.BufferGeometry}options.geometry
    *@param {Cesium.MeshMaterial}options.material
    *@param {Boolean}[options.show=true]
    *@param {Cesium.Cartesian3}[options.position]
    *@param {Cesium.Rotation}[options.rotation]
    *@param {Cesium.Cartesian3}[options.scale]
    *@param {Cesium.MeshMaterial}[material]
    *
    *@property {Cesium.Geometry}geometry
    *@property {Cesium.MeshMaterial}material
    *@property {Boolean}show
    *@property {Cesium.Cartesian3}position
    *@property {Cesium.VolumeRendering.Rotation}rotation
    *@property {Cesium.Cartesian3}scale
    *@property {Boolean}needUpdate
    *@property {Cesium.Mesh|Cesium.LOD}parent
    *
    *@constructor
    *@memberof Cesium
    *@example
        //1.
        var mesh=new Mesh(geomertry,material);

        //2.
        var mesh2=new Mesh({
            geomertry:geomertry2,
            material:material2,
            position:position2
        });

    */
    function Mesh(options) {

        if (Mesh.isGeometrySupported(options)) {
            var geometry = options;

            options = {
                geometry: geometry,
                material: arguments[1]
            };
        }
        if (!options || !options.geometry) {
            throw new Error("geometry是必须参数");
        }
        if (!Mesh.isGeometrySupported(options.geometry)) {
            throw new Error("暂不支持此类型的geometry");
        }

        if (GeometryUtils.isGeometry3js(options.geometry)) {
            options.geometry = GeometryUtils.fromGeometry3js(options.geometry);
        } else if (options.geometry instanceof CSG) {
            if (options.geometry.polygons.length == 0) {
                options.show = false;
            }
            options.geometry = CSG.fromCSG(options.geometry);
        } else if (typeof options.geometry.constructor.createGeometry == 'function') {
            options.geometry = options.geometry.constructor.createGeometry(options.geometry);
        }

        this.uuid = Cesium.createGuid();
        this.show = defaultValue(options.show, true);
        this._geometry = options.geometry;
        this._material = defaultValue(options.material, new MeshMaterial());
        this._position = defaultValue(options.position, new Cesium.Cartesian3(0, 0, 0));
        this._scale = defaultValue(options.scale, new Cesium.Cartesian3(1, 1, 1));
        this._rotation = defaultValue(options.rotation, { axis: new Cesium.Cartesian3(0, 0, 1), angle: 0 });
        this._rotation = new Rotation(this._rotation.axis, this._rotation.angle);
        this._needsUpdate = false;
        this._modelMatrix = new Cesium.Matrix4();
        Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY, this._modelMatrix);

        //用于设置旋转，优先级大于rotation
        this.quaternion = null;

        this._modelMatrixNeedsUpdate = true;
        this._onNeedUpdateChanged = function () {
            this.modelMatrixNeedsUpdate = true;
        };
        this._rotation.paramChanged.removeEventListener(this._onNeedUpdateChanged);
        this._drawCommand = null;
        this._children = [];
        this._parent = null;
        this.userData = {};
        if (!this._geometry.attributes.normal
            && this.material instanceof MeshPhongMaterial
            && this._geometry.primitiveType == Cesium.PrimitiveType.TRIANGLES
            ) {
            Cesium.GeometryPipeline.computeNormal(this._geometry);
            //GeometryUtils.computeVertexNormals(this._geometry);
        }
    }

    Mesh.isGeometrySupported = function (geometry) {
        var supported = (geometry instanceof Cesium.Geometry
            || geometry instanceof CSG
            || typeof geometry.constructor.createGeometry == 'function'
            || GeometryUtils.isGeometry3js(geometry));
        return supported;
    }


    /**
    *
    *@param {Cesium.Mesh|Cesium.LOD}node
    *@param {Cesium.Mesh~TraverseCallback}callback
    */
    Mesh.traverse = function (node, callback) {
        callback(node);
        if (node.children) {
            node.children.forEach(function (child) {
                callback(child);
            })
        }
    }


    /**
     *
     * @callback Cesium.Mesh~TraverseCallback
     * @param {Cesium.Mesh|Cesium.LOD}node
     */

    Object.defineProperties(Mesh.prototype, {

        modelMatrix: {
            get: function () {
                return this._modelMatrix;
            }
        },
        parent: {
            get: function () {
                return this._parent;
            },
            set: function (val) {
                this._parent = val;
                this.modelMatrixNeedsUpdate = true;

            }
        },
        modelMatrixNeedsUpdate: {
            get: function () {
                return this._modelMatrixNeedsUpdate;
            },
            set: function (val) {
                this._modelMatrixNeedsUpdate = val;
                if (this._modelMatrixNeedsUpdate) {
                    Mesh.traverse(this, function (mesh) {
                        mesh._modelMatrixNeedsUpdate = val;
                    });
                }
            }
        },
        children: {
            get: function () {
                return this._children;
            },
            set: function (val) {
                this._children = val;
                this._needsUpdate = true;
            }
        },
        geometry: {
            get: function () {
                return this._geometry;
            },
            set: function (val) {
                this._geometry = val;
                this._needsUpdate = true;
                this.modelMatrixNeedsUpdate = true;
            }
        },
        material: {
            get: function () {
                return this._material;
            },
            set: function (val) {
                this._material = val;
                this._needsUpdate = true;
            }
        },
        needsUpdate: {
            get: function () {
                return this._needsUpdate;
            },
            set: function (val) {
                this._needsUpdate = val;
            }
        },
        rotation: {
            get: function () {
                return this._rotation;
            },
            set: function (val) {
                if (val != this._rotation) {
                    this._rotation = val;
                    // this._needUpdate = true;
                    this.modelMatrixNeedsUpdate = true;
                }
                this._rotation.paramChanged.removeEventListener(this._onNeedUpdateChanged);
                this._rotation = val;
                this._rotation.paramChanged.addEventListener(this._onNeedUpdateChanged);
            }
        },
        position: {
            get: function () {
                return this._position;
            },
            set: function (val) {
                if (val.x != this._position.x || val.y != this._position.y || val.z != this._position.z) {
                    this._position = val;
                    //this._needsUpdate = true;
                    this.modelMatrixNeedsUpdate = true;
                }
                this._position = val;
            }
        },
        scale: {
            get: function () {
                return this._scale;
            },
            set: function (val) {
                if (val.x != this._scale.x || val.y != this._scale.y || val.z != this._scale.z) {
                    this._scale = val;
                    // this._needsUpdate = true;
                    this.modelMatrixNeedsUpdate = true;
                }
                this._scale = val;
            }
        }
    });

    /**
    *@oaram {Cesium.Mesh|Cesium.LOD}child
    */
    Mesh.prototype.add = function (mesh) {

        if (mesh.parent !== this) {
            mesh.parent = this;
        }
        this._children.push(mesh);
    }
    return Mesh;
})
;
define('Core/Shaders/none_frag',[],function () {

    var none_frag = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
varying vec3 v_position;\n\
\n\
uniform vec4 ambientColor;\n\
uniform vec4 diffuseColor;\n\
uniform vec4 specularColor;\n\
uniform float specularShininess;\n\
uniform float picked;\n\
uniform vec4  pickedColor;\n\
\n\
void main(void) \n\
{\n\
    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n\
    vec4 ambient = ambientColor;\n\
    vec4 diffuse = diffuseColor;\n\
    vec4 specular = specularColor;\n\
    color.xyz += ambient.xyz;\n\
    color.xyz += diffuse.xyz;\n\
    color.xyz += specular.xyz;\n\
    color = vec4(color.rgb * diffuse.a, diffuse.a);\n\
    gl_FragColor = color;\n\
    if(picked!=0.0){\n\
        gl_FragColor =mix(color, pickedColor*0.5,1.0);\n\
    }\n\
}";
    return none_frag;

})
;
define('Core/Shaders/none_vert',[],function () {
    var none_vert = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
\n\
\n\
varying vec3 v_position;\n\
\n\
void main(void) \n\
{\n\
    vec4 pos =  modelViewMatrix * vec4( position,1.0);\n\
    v_position = pos.xyz;\n\
    gl_Position =  projectionMatrix * pos;\n\
}";
    return none_vert;
});
define('Core/Shaders/normals_frag',[],function () {
    var normals_frag = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
varying vec3 v_position;\n\
varying vec3 v_normal;\n\
\n\
uniform vec4 ambientColor;\n\
uniform vec4 diffuseColor;\n\
uniform vec4 specularColor;\n\
uniform float specularShininess;\n\
uniform float alpha;\n\
uniform float picked;\n\
uniform vec4  pickedColor;\n\
\n\
varying vec3 v_light0Direction;\n\
\n\
void main(void) \n\
{\n\
    vec3 normal = normalize(v_normal);\n\
    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n\
    vec3 diffuseLight = vec3(0.0, 0.0, 0.0);\n\
    vec3 lightColor = vec3(1.0,1.0,1.0);\n\
vec4 ambient = ambientColor;\n\
    vec4 diffuse = diffuseColor;\n\
    vec4 specular = specularColor;\n\
\n\
    vec3 specularLight = vec3(0.0, 0.0, 0.0);\n\
    {\n\
        float specularIntensity = 0.0;\n\
        float attenuation = 1.0;\n\
        vec3 l = normalize(v_light0Direction);\n\
        vec3 viewDir = -normalize(v_position);\n\
        vec3 h = normalize(l+viewDir);\n\
        specularIntensity = max(0.0, pow(max(dot(normal,h), 0.0) , specularShininess)) * attenuation;\n\
        specularLight += lightColor * specularIntensity;\n\
        diffuseLight += lightColor * max(dot(normal,l), 0.0) * attenuation;\n\
    }\n\
    //specular.xyz *= specularLight;\n\
    //diffuse.xyz *= diffuseLight;\n\
    color.xyz += ambient.xyz;\n\
    color.xyz += diffuse.xyz;\n\
    color.xyz += specular.xyz;\n\
    color = vec4(color.rgb * diffuse.a, diffuse.a*alpha);\n\
    gl_FragColor = color;\n\
    if(picked!=0.0){\n\
        gl_FragColor =mix(color, pickedColor*0.5,1.0);\n\
    }\n\
}";
    return normals_frag;
});
define('Core/Shaders/normals_vert',[],function () {
    var normals_vert = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
\n\
\n\
varying vec3 v_position;\n\
varying vec3 v_normal;\n\
\n\
varying vec3 v_light0Direction;\n\
\n\
void main(void) \n\
{\n\
    vec4 pos =  modelViewMatrix * vec4( position,1.0);\n\
    v_normal =  normalMatrix *  normal;\n\
    v_position = pos.xyz;\n\
    v_light0Direction = mat3( modelViewMatrix) * vec3(1.0,1.0,1.0);\n\
    gl_Position =  projectionMatrix * pos;\n\
}";

    return normals_vert;
});
define('Core/Shaders/texture_frag',[],function () {
    var texture_frag = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
varying vec3 v_position;\n\
varying vec2 v_texcoord0;\n\
\n\
uniform vec4 ambientColor;\n\
uniform sampler2D diffuseColorMap;\n\
uniform vec4 specularColor;\n\
uniform float specularShininess;\n\
uniform float picked;\n\
uniform vec4  pickedColor;\n\
\n\
uniform float alpha;\n\
\n\
void main(void) \n\
{\n\
    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n\
    vec3 diffuseLight = vec3(0.0, 0.0, 0.0);\n\
    vec3 lightColor = vec3(1.0,1.0,1.0);\n\
    vec4 ambient = ambientColor;\n\
    vec4 diffuse = texture2D(diffuseColorMap, v_texcoord0);\n\
    vec4 specular = specularColor;\n\
    color.xyz += ambient.xyz;\n\
    color.xyz += diffuse.xyz;\n\
    color.xyz += specular.xyz;\n\
    color = vec4(diffuse.rgb * diffuse.a, diffuse.a*alpha);\n\
    gl_FragColor = color;\n\
    if(picked!=0.0){\n\
        gl_FragColor =mix(color, pickedColor*0.5,1.0);\n\
    }\n\
}";
    return texture_frag;
})
;
define('Core/Shaders/texture_vert',[],function () {
    var texture_vert = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
\n\
\n\
varying vec3 v_position;\n\
varying vec2 v_texcoord0;\n\
\n\
void main(void) \n\
{\n\
    vec4 pos =  modelViewMatrix * vec4( position,1.0);\n\
    v_texcoord0 =  uv;\n\
    v_position = pos.xyz;\n\
    gl_Position =  projectionMatrix * pos;\n\
}";

    return texture_vert;
});
define('Core/Shaders/texture_normals_frag',[],function () {
    var texture_normals_frag = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
varying vec3 v_position;\n\
varying vec2 v_texcoord0;\n\
varying vec3 v_normal;\n\
\n\
uniform vec4 ambientColor;\n\
uniform sampler2D diffuseColorMap;\n\
uniform vec4 specularColor;\n\
uniform float specularShininess;\n\
uniform float picked;\n\
uniform vec4  pickedColor;\n\
\n\
varying vec3 v_light0Direction;\n\
\n\
void main(void) \n\
{\n\
    vec3 normal = normalize(v_normal);\n\
    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);\n\
    vec3 diffuseLight = vec3(0.0, 0.0, 0.0);\n\
    vec3 lightColor = vec3(1.0,1.0,1.0);\n\
    vec4 ambient = ambientColor;\n\
    vec4 diffuse = texture2D(diffuseColorMap, v_texcoord0);\n\
    vec4 specular = specularColor;\n\
\n\
    vec3 specularLight = vec3(0.0, 0.0, 0.0);\n\
    {\n\
        float specularIntensity = 0.0;\n\
        float attenuation = 1.0;\n\
        vec3 l = normalize(v_light0Direction);\n\
        vec3 viewDir = -normalize(v_position);\n\
        vec3 h = normalize(l+viewDir);\n\
        specularIntensity = max(0.0, pow(max(dot(normal,h), 0.0) , specularShininess)) * attenuation;\n\
        specularLight += lightColor * specularIntensity;\n\
        diffuseLight += lightColor * max(dot(normal,l), 0.0) * attenuation;\n\
    }\n\
    //specular.xyz *= specularLight;\n\
    //diffuse.xyz *= diffuseLight;\n\
    color.xyz += ambient.xyz;\n\
    color.xyz += diffuse.xyz;\n\
    color.xyz += specular.xyz;\n\
    color = vec4(diffuse.rgb * diffuse.a, diffuse.a);\n\
    gl_FragColor = color;\n\
    if(picked!=0.0){\n\
        gl_FragColor = pickedColor*color;\n\
    }\n\
}";

    return texture_normals_frag;
});
define('Core/Shaders/texture_normals_vert',[],function () {
    var texture_normals_vert = "\n\
#ifdef GL_ES\n\
    precision highp float;\n\
#endif\n\
\n\
\n\
\n\
varying vec3 v_position;\n\
varying vec2 v_texcoord0;\n\
varying vec3 v_normal;\n\
\n\
varying vec3 v_light0Direction;\n\
\n\
void main(void) \n\
{\n\
    vec4 pos =  modelViewMatrix * vec4( position,1.0);\n\
    v_normal =  normalMatrix *  normal;\n\
    v_texcoord0 =uv;\n\
    v_position = pos.xyz;\n\
    v_light0Direction = mat3( modelViewMatrix) * vec3(1.0,1.0,1.0);\n\
    gl_Position =  projectionMatrix * pos;\n\
}";
    return texture_normals_vert;
});
define('Core/Shaders/ShaderChunk',[
    "Core/Shaders/none_frag",
    "Core/Shaders/none_vert",
    "Core/Shaders/normals_frag",
    "Core/Shaders/normals_vert",
    "Core/Shaders/texture_frag",
    "Core/Shaders/texture_vert",
    "Core/Shaders/texture_normals_frag",
    "Core/Shaders/texture_normals_vert"
], function (
    none_frag,
    none_vert,
    normals_frag,
    normals_vert,
    texture_frag,
    texture_vert,
    texture_normals_frag,
    texture_normals_vert
    ) {

    var alphamap_fragment = "#ifdef USE_ALPHAMAP\n\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif\n";

    var alphamap_pars_fragment = "#ifdef USE_ALPHAMAP\n\tuniform sampler2D alphaMap;\n#endif\n";

    var alphatest_fragment = "#ifdef ALPHATEST\n\tif ( diffuseColor.a < ALPHATEST ) discard;\n#endif\n";

    var aomap_fragment = "#ifdef USE_AOMAP\n\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n\treflectedLight.indirectDiffuse *= ambientOcclusion;\n\t#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n\t#endif\n#endif\n";

    var aomap_pars_fragment = "#ifdef USE_AOMAP\n\tuniform sampler2D aoMap;\n\tuniform float aoMapIntensity;\n#endif";

    var begin_vertex = "\nvec3 transformed = vec3( position );\n";

    var beginnormal_vertex = "\nvec3 objectNormal = vec3( normal );\n";

    var bsdfs = "float punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n\tif( decayExponent > 0.0 ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n\t\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n\t\tfloat maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n\t\treturn distanceFalloff * maxDistanceCutoffFactor;\n#else\n\t\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n#endif\n\t}\n\treturn 1.0;\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n\treturn RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\treturn 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n\tfloat a2 = pow2( alpha );\n\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n\treturn 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n\tfloat a2 = pow2( alpha );\n\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n\treturn RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n\tfloat alpha = pow2( roughness );\n\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n\tfloat dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );\n\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\n\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n\tvec3 F = F_Schlick( specularColor, dotLH );\n\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n\tfloat D = D_GGX( alpha, dotNH );\n\treturn F * ( G * D );\n}\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\n\tconst float LUT_SIZE  = 64.0;\n\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\n\tconst float LUT_BIAS  = 0.5 / LUT_SIZE;\n\tfloat theta = acos( dot( N, V ) );\n\tvec2 uv = vec2(\n\t\tsqrt( saturate( roughness ) ),\n\t\tsaturate( theta / ( 0.5 * PI ) ) );\n\tuv = uv * LUT_SCALE + LUT_BIAS;\n\treturn uv;\n}\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\n\tfloat l = length( f );\n\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\n}\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\n\tfloat x = dot( v1, v2 );\n\tfloat y = abs( x );\n\tfloat a = 0.86267 + (0.49788 + 0.01436 * y ) * y;\n\tfloat b = 3.45068 + (4.18814 + y) * y;\n\tfloat v = a / b;\n\tfloat theta_sintheta = (x > 0.0) ? v : 0.5 * inversesqrt( 1.0 - x * x ) - v;\n\treturn cross( v1, v2 ) * theta_sintheta;\n}\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\n\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\n\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\n\tvec3 lightNormal = cross( v1, v2 );\n\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\n\tvec3 T1, T2;\n\tT1 = normalize( V - N * dot( V, N ) );\n\tT2 = - cross( N, T1 );\n\tmat3 mat = mInv * transpose( mat3( T1, T2, N ) );\n\tvec3 coords[ 4 ];\n\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\n\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\n\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\n\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\n\tcoords[ 0 ] = normalize( coords[ 0 ] );\n\tcoords[ 1 ] = normalize( coords[ 1 ] );\n\tcoords[ 2 ] = normalize( c

    var bumpmap_pars_fragment = "#ifdef USE_BUMPMAP\n\tuniform sampler2D bumpMap;\n\tuniform float bumpScale;\n\tvec2 dHdxy_fwd() {\n\t\tvec2 dSTdx = dFdx( vUv );\n\t\tvec2 dSTdy = dFdy( vUv );\n\t\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n\t\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n\t\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n\t\treturn vec2( dBx, dBy );\n\t}\n\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n\t\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\n\t\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\n\t\tvec3 vN = surf_norm;\n\t\tvec3 R1 = cross( vSigmaY, vN );\n\t\tvec3 R2 = cross( vN, vSigmaX );\n\t\tfloat fDet = dot( vSigmaX, R1 );\n\t\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n\t\treturn normalize( abs( fDet ) * surf_norm - vGrad );\n\t}\n#endif\n";

    var clipping_planes_fragment = "#if NUM_CLIPPING_PLANES > 0\n\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; ++ i ) {\n\t\tvec4 plane = clippingPlanes[ i ];\n\t\tif ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;\n\t}\n\t\t\n\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\n\t\tbool clipped = true;\n\t\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; ++ i ) {\n\t\t\tvec4 plane = clippingPlanes[ i ];\n\t\t\tclipped = ( dot( vViewPosition, plane.xyz ) > plane.w ) && clipped;\n\t\t}\n\t\tif ( clipped ) discard;\n\t\n\t#endif\n#endif\n";

    var clipping_planes_pars_fragment = "#if NUM_CLIPPING_PLANES > 0\n\t#if ! defined( PHYSICAL ) && ! defined( PHONG )\n\t\tvarying vec3 vViewPosition;\n\t#endif\n\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif\n";

    var clipping_planes_pars_vertex = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n\tvarying vec3 vViewPosition;\n#endif\n";

    var clipping_planes_vertex = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n";

    var color_fragment = "#ifdef USE_COLOR\n\tdiffuseColor.rgb *= vColor;\n#endif";

    var color_pars_fragment = "#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif\n";

    var color_pars_vertex = "#ifdef USE_COLOR\n\tvarying vec3 vColor;\n#endif";

    var color_vertex = "#ifdef USE_COLOR\n\tvColor.xyz = color.xyz;\n#endif";

    var common = "#define PI 3.14159265359\n#define PI2 6.28318530718\n#define PI_HALF 1.5707963267949\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 pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\n\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n\treturn fract(sin(sn) * c);\n}\nstruct IncidentLight {\n\tvec3 color;\n\tvec3 direction;\n\tbool visible;\n};\nstruct ReflectedLight {\n\tvec3 directDiffuse;\n\tvec3 directSpecular;\n\tvec3 indirectDiffuse;\n\tvec3 indirectSpecular;\n};\nstruct GeometricContext {\n\tvec3 position;\n\tvec3 normal;\n\tvec3 viewDir;\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\tfloat distance = dot( planeNormal, point - pointOnPlane );\n\treturn - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\nmat3 transpose( const in mat3 v ) {\n\tmat3 tmp;\n\ttmp[0] = vec3(v[0].x, v[1].x, v[2].x);\n\ttmp[1] = vec3(v[0].y, v[1].y, v[2].y);\n\ttmp[2] = vec3(v[0].z, v[1].z, v[2].z);\n\treturn tmp;\n}\n";

    var cube_uv_reflection_fragment = "#ifdef ENVMAP_TYPE_CUBE_UV\n#define cubeUV_textureSize (1024.0)\nint getFaceFromDirection(vec3 direction) {\n\tvec3 absDirection = abs(direction);\n\tint face = -1;\n\tif( absDirection.x > absDirection.z ) {\n\t\tif(absDirection.x > absDirection.y )\n\t\t\tface = direction.x > 0.0 ? 0 : 3;\n\t\telse\n\t\t\tface = direction.y > 0.0 ? 1 : 4;\n\t}\n\telse {\n\t\tif(absDirection.z > absDirection.y )\n\t\t\tface = direction.z > 0.0 ? 2 : 5;\n\t\telse\n\t\t\tface = direction.y > 0.0 ? 1 : 4;\n\t}\n\treturn face;\n}\n#define cubeUV_maxLods1  (log2(cubeUV_textureSize*0.25) - 1.0)\n#define cubeUV_rangeClamp (exp2((6.0 - 1.0) * 2.0))\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\n\tfloat scale = exp2(cubeUV_maxLods1 - roughnessLevel);\n\tfloat dxRoughness = dFdx(roughness);\n\tfloat dyRoughness = dFdy(roughness);\n\tvec3 dx = dFdx( vec * scale * dxRoughness );\n\tvec3 dy = dFdy( vec * scale * dyRoughness );\n\tfloat d = max( dot( dx, dx ), dot( dy, dy ) );\n\td = clamp(d, 1.0, cubeUV_rangeClamp);\n\tfloat mipLevel = 0.5 * log2(d);\n\treturn vec2(floor(mipLevel), fract(mipLevel));\n}\n#define cubeUV_maxLods2 (log2(cubeUV_textureSize*0.25) - 2.0)\n#define cubeUV_rcpTextureSize (1.0 / cubeUV_textureSize)\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\n\tmipLevel = roughnessLevel > cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\n\tfloat a = 16.0 * cubeUV_rcpTextureSize;\n\tvec2 exp2_packed = exp2( vec2( roughnessLevel, mipLevel ) );\n\tvec2 rcp_exp2_packed = vec2( 1.0 ) / exp2_packed;\n\tfloat powScale = exp2_packed.x * exp2_packed.y;\n\tfloat scale = rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\n\tfloat mipOffset = 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\n\tbool bRes = mipLevel == 0.0;\n\tscale =  bRes && (scale < a) ? a : scale;\n\tvec3 r;\n\tvec2 offset;\n\tint face = getFaceFromDirection(direction);\n\tfloat rcpPowScale = 1.0 / powScale;\n\tif( face == 0) {\n\t\tr = vec3(direction.x, -direction.z, direction.y);\n\t\toffset = vec2(0.0+mipOffset,0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 1) {\n\t\tr = vec3(direction.y, direction.x, direction.z);\n\t\toffset = vec2(scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 2) {\n\t\tr = vec3(direction.z, direction.x, direction.y);\n\t\toffset = vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\n\t}\n\telse if( face == 3) {\n\t\tr = vec3(direction.x, direction.z, direction.y);\n\t\toffset = vec2(0.0+mipOffset,0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse if( face == 4) {\n\t\tr = vec3(direction.y, direction.x, -direction.z);\n\t\toffset = vec2(scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\telse {\n\t\tr = vec3(direction.z, -direction.x, direction.y);\n\t\toffset = vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\n\t\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\n\t}\n\tr = normalize(r);\n\tfloat texelOffset = 0.5 * cubeUV_rcpTextureSize;\n\tvec2 s = ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\n\tvec2 base = offset + vec2( texelOffset );\n\treturn base + s * ( scale - 2.0 * texelOffset );\n}\n#define cubeUV_maxLods3 (log2(cubeUV_textureSize*0.25) - 3.0)\nvec4 textureCubeUV(vec3 reflectedDirection, float roughness ) {\n\tfloat roughnessVal = roughness* cubeUV_maxLods3;\n\tfloat r1 = floor(roughnessVal);\n\tfloat r2 = r1 + 1.0;\n\tfloat t = fract(roughnessVal);\n\tvec2 mipInfo = MipLevelInfo(reflectedDirection, r1, roughness);\n\tfloat s = mipInfo.y;\n\tfloat level0 = mipInfo.x;\n\tfloat level1 = level0 + 1.0;\n\tlevel1 = level1 > 5.0 ? 5.0 : level1;\n\tlevel0 += min( floor( s + 0.5 ), 5.0 );\n\tvec2 uv_10 = getCubeUV(reflectedDirection, r1, level0);\n\tvec4 color10 = envMapTexelToLinear(texture2D(envMap, uv_10));\n\tvec2 uv_20 = getCubeUV(reflectedDirection, r2, level0);\n\tvec4 color20 = envMapTexelTo

    var defaultnormal_vertex = "vec3 transformedNormal = normalMatrix * objectNormal;\n#ifdef FLIP_SIDED\n\ttransformedNormal = - transformedNormal;\n#endif\n";

    var displacementmap_pars_vertex = "#ifdef USE_DISPLACEMENTMAP\n\tuniform sampler2D displacementMap;\n\tuniform float displacementScale;\n\tuniform float displacementBias;\n#endif\n";

    var displacementmap_vertex = "#ifdef USE_DISPLACEMENTMAP\n\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif\n";

    var emissivemap_fragment = "#ifdef USE_EMISSIVEMAP\n\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\n\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n\ttotalEmissiveRadiance *= emissiveColor.rgb;\n#endif\n";

    var emissivemap_pars_fragment = "#ifdef USE_EMISSIVEMAP\n\tuniform sampler2D emissiveMap;\n#endif\n";

    var encodings_fragment = "  gl_FragColor = linearToOutputTexel( gl_FragColor );\n";

    var encodings_pars_fragment = "\nvec4 LinearToLinear( in vec4 value ) {\n\treturn value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n\treturn vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n\tfloat maxComponent = max( max( value.r, value.g ), value.b );\n\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.xyz * value.w * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\n\tfloat M      = clamp( maxRGB / maxRange, 0.0, 1.0 );\n\tM            = ceil( M * 255.0 ) / 255.0;\n\treturn vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\n\tfloat D      = max( maxRange / maxRGB, 1.0 );\n\tD            = min( floor( D ) / 255.0, 1.0 );\n\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value )  {\n\tvec3 Xp_Y_XYZp = value.rgb * cLogLuvM;\n\tXp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));\n\tvec4 vResult;\n\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n\tvResult.w = fract(Le);\n\tvResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;\n\treturn vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n\tfloat Le = value.z * 255.0 + value.w;\n\tvec3 Xp_Y_XYZp;\n\tXp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);\n\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n\tvec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;\n\treturn vec4( max(vRGB, 0.0), 1.0 );\n}\n";

    var envmap_fragment = "#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\tvec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );\n\t\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvec3 reflectVec = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#else\n\t\tvec3 reflectVec = vReflect;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tvec4 envColor = textureCube( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n\t#elif defined( ENVMAP_TYPE_EQUIREC )\n\t\tvec2 sampleUV;\n\t\tsampleUV.y = asin( flipNormal * reflectVec.y ) * RECIPROCAL_PI + 0.5;\n\t\tsampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n\t\tvec4 envColor = texture2D( envMap, sampleUV );\n\t#elif defined( ENVMAP_TYPE_SPHERE )\n\t\tvec3 reflectView = flipNormal * normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );\n\t\tvec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n\t#else\n\t\tvec4 envColor = vec4( 0.0 );\n\t#endif\n\tenvColor = envMapTexelToLinear( envColor );\n\t#ifdef ENVMAP_BLENDING_MULTIPLY\n\t\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_MIX )\n\t\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n\t#elif defined( ENVMAP_BLENDING_ADD )\n\t\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\n\t#endif\n#endif\n";

    var envmap_pars_fragment = "#if defined( USE_ENVMAP ) || defined( PHYSICAL )\n\tuniform float reflectivity;\n\tuniform float envMapIntensity;\n#endif\n#ifdef USE_ENVMAP\n\t#if ! defined( PHYSICAL ) && ( defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) )\n\t\tvarying vec3 vWorldPosition;\n\t#endif\n\t#ifdef ENVMAP_TYPE_CUBE\n\t\tuniform samplerCube envMap;\n\t#else\n\t\tuniform sampler2D envMap;\n\t#endif\n\tuniform float flipEnvMap;\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( PHYSICAL )\n\t\tuniform float refractionRatio;\n\t#else\n\t\tvarying vec3 vReflect;\n\t#endif\n#endif\n";

    var envmap_pars_vertex = "#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\tvarying vec3 vWorldPosition;\n\t#else\n\t\tvarying vec3 vReflect;\n\t\tuniform float refractionRatio;\n\t#endif\n#endif\n";

    var envmap_vertex = "#ifdef USE_ENVMAP\n\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n\t\tvWorldPosition = worldPosition.xyz;\n\t#else\n\t\tvec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n\t\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n\t\t#ifdef ENVMAP_MODE_REFLECTION\n\t\t\tvReflect = reflect( cameraToVertex, worldNormal );\n\t\t#else\n\t\t\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n\t\t#endif\n\t#endif\n#endif\n";

    var fog_vertex = "\n#ifdef USE_FOG\nfogDepth = -mvPosition.z;\n#endif";

    var fog_pars_vertex = "#ifdef USE_FOG\n  varying float fogDepth;\n#endif\n";

    var fog_fragment = "#ifdef USE_FOG\n\t#ifdef FOG_EXP2\n\t\tfloat fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 ) );\n\t#else\n\t\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\n\t#endif\n\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif\n";

    var fog_pars_fragment = "#ifdef USE_FOG\n\tuniform vec3 fogColor;\n\tvarying float fogDepth;\n\t#ifdef FOG_EXP2\n\t\tuniform float fogDensity;\n\t#else\n\t\tuniform float fogNear;\n\t\tuniform float fogFar;\n\t#endif\n#endif\n";

    var gradientmap_pars_fragment = "#ifdef TOON\n\tuniform sampler2D gradientMap;\n\tvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\n\t\tfloat dotNL = dot( normal, lightDirection );\n\t\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\n\t\t#ifdef USE_GRADIENTMAP\n\t\t\treturn texture2D( gradientMap, coord ).rgb;\n\t\t#else\n\t\t\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\n\t\t#endif\n\t}\n#endif\n";

    var lightmap_fragment = "#ifdef USE_LIGHTMAP\n\treflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif\n";

    var lightmap_pars_fragment = "#ifdef USE_LIGHTMAP\n\tuniform sampler2D lightMap;\n\tuniform float lightMapIntensity;\n#endif";

    var 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\tvLightBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS > 0\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_DIR_LIGHTS > 0\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n\t\tdotNL = dot( geometry.normal, directLight.direction );\n\t\tdirectLightColor_Diffuse = PI * directLight.color;\n\t\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n\t\t#endif\n\t}\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\tvLightFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t#ifdef DOUBLE_SIDED\n\t\t\tvLightBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n\t\t#endif\n\t}\n#endif\n";

    var lights_pars = "uniform vec3 ambientLightColor;\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n\tvec3 irradiance = ambientLightColor;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treturn irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n\tstruct DirectionalLight {\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tdirectLight.color = directionalLight.color;\n\t\tdirectLight.direction = directionalLight.direction;\n\t\tdirectLight.visible = true;\n\t}\n#endif\n#if NUM_POINT_LIGHTS > 0\n\tstruct PointLight {\n\t\tvec3 position;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n\t\tvec3 lVector = pointLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tdirectLight.color = pointLight.color;\n\t\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n\t\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\n\t}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n\tstruct SpotLight {\n\t\tvec3 position;\n\t\tvec3 direction;\n\t\tvec3 color;\n\t\tfloat distance;\n\t\tfloat decay;\n\t\tfloat coneCos;\n\t\tfloat penumbraCos;\n\t\tint shadow;\n\t\tfloat shadowBias;\n\t\tfloat shadowRadius;\n\t\tvec2 shadowMapSize;\n\t};\n\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\n\t\tvec3 lVector = spotLight.position - geometry.position;\n\t\tdirectLight.direction = normalize( lVector );\n\t\tfloat lightDistance = length( lVector );\n\t\tfloat angleCos = dot( directLight.direction, spotLight.direction );\n\t\tif ( angleCos > spotLight.coneCos ) {\n\t\t\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n\t\t\tdirectLight.color = spotLight.color;\n\t\t\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n\t\t\tdirectLight.visible = true;\n\t\t} else {\n\t\t\tdirectLight.color = vec3( 0.0 );\n\t\t\tdirectLight.visible = false;\n\t\t}\n\t}\n#endif\n#if NUM_RECT_AREA_LIGHTS > 0\n\tstruct RectAreaLight {\n\t\tvec3 color;\n\t\tvec3 position;\n\t\tvec3 halfWidth;\n\t\tvec3 halfHeight;\n\t};\n\tuniform sampler2D ltcMat;\tuniform sampler2D ltcMag;\n\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\n#endif\n#if NUM_HEMI_LIGHTS > 0\n\tstruct HemisphereLight {\n\t\tvec3 direction;\n\t\tvec3 skyColor;\n\t\tvec3 groundColor;\n\t};\n\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n\t\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\n\t\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n\t\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tirradiance *= PI;\n\t\t#endif\n\t\treturn irradiance;\n\t}\n#endif\n#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n\t\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n\t\t#ifdef ENVMAP_TYPE_CUBE\n\t\t\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n\t\t\t#ifdef TEXTURE_LOD_EXT\n\t\t\t\tvec4 envMapColor

    var lights_phong_fragment = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;\n";

    var lights_phong_pars_fragment = "varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n\tvec3\tdiffuseColor;\n\tvec3\tspecularColor;\n\tfloat\tspecularShininess;\n\tfloat\tspecularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n\t#ifdef TOON\n\t\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\n\t#else\n\t\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\t\tvec3 irradiance = dotNL * directLight.color;\n\t#endif\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\treflectedLight.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\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct\t\t\t\tRE_Direct_BlinnPhong\n#define RE_IndirectDiffuse\t\tRE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )\t(0)\n";

    var lights_physical_fragment = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\n#ifdef STANDARD\n\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\n#else\n\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n\tmaterial.clearCoat = saturate( clearCoat );\tmaterial.clearCoatRoughness = clamp( clearCoatRoughness, 0.04, 1.0 );\n#endif\n";

    var lights_physical_pars_fragment = "struct PhysicalMaterial {\n\tvec3\tdiffuseColor;\n\tfloat\tspecularRoughness;\n\tvec3\tspecularColor;\n\t#ifndef STANDARD\n\t\tfloat clearCoat;\n\t\tfloat clearCoatRoughness;\n\t#endif\n};\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\nfloat clearCoatDHRApprox( const in float roughness, const in float dotNL ) {\n\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\n}\n#if NUM_RECT_AREA_LIGHTS > 0\n\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t\tvec3 normal = geometry.normal;\n\t\tvec3 viewDir = geometry.viewDir;\n\t\tvec3 position = geometry.position;\n\t\tvec3 lightPos = rectAreaLight.position;\n\t\tvec3 halfWidth = rectAreaLight.halfWidth;\n\t\tvec3 halfHeight = rectAreaLight.halfHeight;\n\t\tvec3 lightColor = rectAreaLight.color;\n\t\tfloat roughness = material.specularRoughness;\n\t\tvec3 rectCoords[ 4 ];\n\t\trectCoords[ 0 ] = lightPos - halfWidth - halfHeight;\t\trectCoords[ 1 ] = lightPos + halfWidth - halfHeight;\n\t\trectCoords[ 2 ] = lightPos + halfWidth + halfHeight;\n\t\trectCoords[ 3 ] = lightPos - halfWidth + halfHeight;\n\t\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\n\t\tfloat norm = texture2D( ltcMag, uv ).a;\n\t\tvec4 t = texture2D( ltcMat, uv );\n\t\tmat3 mInv = mat3(\n\t\t\tvec3(   1,   0, t.y ),\n\t\t\tvec3(   0, t.z,   0 ),\n\t\t\tvec3( t.w,   0, t.x )\n\t\t);\n\t\treflectedLight.directSpecular += lightColor * material.specularColor * norm * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\n\t\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1 ), rectCoords );\n\t}\n#endif\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n\tvec3 irradiance = dotNL * directLight.color;\n\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\tirradiance *= PI;\n\t#endif\n\t#ifndef STANDARD\n\t\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\n\t#else\n\t\tfloat clearCoatDHR = 0.0;\n\t#endif\n\treflectedLight.directSpecular += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );\n\treflectedLight.directDiffuse += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n\t#ifndef STANDARD\n\t\treflectedLight.directSpecular += irradiance * material.clearCoat * BRDF_Specular_GGX( directLight, geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness );\n\t#endif\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 clearCoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n\t#ifndef STANDARD\n\t\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n\t\tfloat dotNL = dotNV;\n\t\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\n\t#else\n\t\tfloat clearCoatDHR = 0.0;\n\t#endif\n\treflectedLight.indirectSpecular += ( 1.0 - clearCoatDHR ) * radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );\n\t#ifndef STANDARD\n\t\treflectedLight.indirectSpecular += clearCoatRadiance * material.clearCoat * BRDF_Specular_GGX_Environment( geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness )

    var 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\tPointLight pointLight;\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\n\t\t#ifdef USE_SHADOWMAP\n\t\tdirectLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\tSpotLight spotLight;\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\t\t#ifdef USE_SHADOWMAP\n\t\tdirectLight.color *= all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n\tDirectionalLight directionalLight;\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\t\t#ifdef USE_SHADOWMAP\n\t\tdirectLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t\t#endif\n\t\tRE_Direct( directLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\tRectAreaLight rectAreaLight;\n\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\t\trectAreaLight = rectAreaLights[ i ];\n\t\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\t}\n#endif\n#if defined( RE_IndirectDiffuse )\n\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\t#ifdef USE_LIGHTMAP\n\t\tvec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t\t#ifndef PHYSICALLY_CORRECT_LIGHTS\n\t\t\tlightMapIrradiance *= PI;\n\t\t#endif\n\t\tirradiance += lightMapIrradiance;\n\t#endif\n\t#if ( NUM_HEMI_LIGHTS > 0 )\n\t\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\t\t\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\t\t}\n\t#endif\n\t#if defined( USE_ENVMAP ) && defined( PHYSICAL ) && defined( ENVMAP_TYPE_CUBE_UV )\n\t\tirradiance += getLightProbeIndirectIrradiance( geometry, 8 );\n\t#endif\n\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n\tvec3 radiance = getLightProbeIndirectRadiance( geometry, Material_BlinnShininessExponent( material ), 8 );\n\t#ifndef STANDARD\n\t\tvec3 clearCoatRadiance = getLightProbeIndirectRadiance( geometry, Material_ClearCoat_BlinnShininessExponent( material ), 8 );\n\t#else\n\t\tvec3 clearCoatRadiance = vec3( 0.0 );\n\t#endif\n\tRE_IndirectSpecular( radiance, clearCoatRadiance, geometry, material, reflectedLight );\n#endif\n";

    var logdepthbuf_fragment = "#if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)\n\tgl_FragDepthEXT = log2(vFragDepth) * logDepthBufFC * 0.5;\n#endif";

    var logdepthbuf_pars_fragment = "#ifdef USE_LOGDEPTHBUF\n\tuniform float logDepthBufFC;\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t#endif\n#endif\n";

    var logdepthbuf_pars_vertex = "#ifdef USE_LOGDEPTHBUF\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvarying float vFragDepth;\n\t#endif\n\tuniform float logDepthBufFC;\n#endif";

    var logdepthbuf_vertex = "#ifdef USE_LOGDEPTHBUF\n\tgl_Position.z = log2(max( EPSILON, gl_Position.w + 1.0 )) * logDepthBufFC;\n\t#ifdef USE_LOGDEPTHBUF_EXT\n\t\tvFragDepth = 1.0 + gl_Position.w;\n\t#else\n\t\tgl_Position.z = (gl_Position.z - 1.0) * gl_Position.w;\n\t#endif\n#endif\n";

    var map_fragment = "#ifdef USE_MAP\n\tvec4 texelColor = texture2D( map, vUv );\n\ttexelColor = mapTexelToLinear( texelColor );\n\tdiffuseColor *= texelColor;\n#endif\n";

    var map_pars_fragment = "#ifdef USE_MAP\n\tuniform sampler2D map;\n#endif\n";

    var map_particle_fragment = "#ifdef USE_MAP\n\tvec4 mapTexel = texture2D( map, vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y ) * offsetRepeat.zw + offsetRepeat.xy );\n\tdiffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n";

    var map_particle_pars_fragment = "#ifdef USE_MAP\n\tuniform vec4 offsetRepeat;\n\tuniform sampler2D map;\n#endif\n";

    var metalnessmap_fragment = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\n\tmetalnessFactor *= texelMetalness.b;\n#endif\n";

    var metalnessmap_pars_fragment = "#ifdef USE_METALNESSMAP\n\tuniform sampler2D metalnessMap;\n#endif";

    var morphnormal_vertex = "#ifdef USE_MORPHNORMALS\n\tobjectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n\tobjectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n\tobjectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n\tobjectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif\n";

    var morphtarget_pars_vertex = "#ifdef USE_MORPHTARGETS\n\t#ifndef USE_MORPHNORMALS\n\tuniform float morphTargetInfluences[ 8 ];\n\t#else\n\tuniform float morphTargetInfluences[ 4 ];\n\t#endif\n#endif";

    var morphtarget_vertex = "#ifdef USE_MORPHTARGETS\n\ttransformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n\ttransformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n\ttransformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n\ttransformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n\t#ifndef USE_MORPHNORMALS\n\ttransformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n\ttransformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n\ttransformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n\ttransformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n\t#endif\n#endif\n";

    var normal_flip = "#ifdef DOUBLE_SIDED\n\tfloat flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n#else\n\tfloat flipNormal = 1.0;\n#endif\n";

    var normal_fragment = "#ifdef FLAT_SHADED\n\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n\tvec3 normal = normalize( cross( fdx, fdy ) );\n#else\n\tvec3 normal = normalize( vNormal ) * flipNormal;\n#endif\n#ifdef USE_NORMALMAP\n\tnormal = perturbNormal2Arb( -vViewPosition, normal );\n#elif defined( USE_BUMPMAP )\n\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif\n";

    var normalmap_pars_fragment = "#ifdef USE_NORMALMAP\n\tuniform sampler2D normalMap;\n\tuniform vec2 normalScale;\n\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {\n\t\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\n\t\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\n\t\tvec2 st0 = dFdx( vUv.st );\n\t\tvec2 st1 = dFdy( vUv.st );\n\t\tvec3 S = normalize( q0 * st1.t - q1 * st0.t );\n\t\tvec3 T = normalize( -q0 * st1.s + q1 * st0.s );\n\t\tvec3 N = normalize( surf_norm );\n\t\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n\t\tmapN.xy = normalScale * mapN.xy;\n\t\tmat3 tsn = mat3( S, T, N );\n\t\treturn normalize( tsn * mapN );\n\t}\n#endif\n";

    var packing = "vec3 packNormalToRGB( const in vec3 normal ) {\n\treturn normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n\treturn 1.0 - 2.0 * rgb.xyz;\n}\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256.,  256. );\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\nconst float ShiftRight8 = 1. / 256.;\nvec4 packDepthToRGBA( const in float v ) {\n\tvec4 r = vec4( fract( v * PackFactors ), v );\n\tr.yzw -= r.xyz * ShiftRight8;\treturn r * PackUpscale;\n}\nfloat unpackRGBAToDepth( const in vec4 v ) {\n\treturn dot( v, UnpackFactors );\n}\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn ( viewZ + near ) / ( near - far );\n}\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n\treturn linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\n}\n";

    var premultiplied_alpha_fragment = "#ifdef PREMULTIPLIED_ALPHA\n\tgl_FragColor.rgb *= gl_FragColor.a;\n#endif\n";

    var project_vertex = "vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\ngl_Position = projectionMatrix * mvPosition;\n";

    var dithering_fragment = "#if defined( DITHERING )\n  gl_FragColor.rgb = dithering( gl_FragColor.rgb );\n#endif\n";

    var dithering_pars_fragment = "#if defined( DITHERING )\n\tvec3 dithering( vec3 color ) {\n\t\tfloat grid_position = rand( gl_FragCoord.xy );\n\t\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\n\t\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\n\t\treturn color + dither_shift_RGB;\n\t}\n#endif\n";

    var roughnessmap_fragment = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\n\troughnessFactor *= texelRoughness.g;\n#endif\n";

    var roughnessmap_pars_fragment = "#ifdef USE_ROUGHNESSMAP\n\tuniform sampler2D roughnessMap;\n#endif";

    var shadowmap_pars_fragment = "#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\t\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHTS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\t\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHTS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\t\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHTS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n\t#endif\n\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n\t\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n\t}\n\tfloat texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n\t\tconst vec2 offset = vec2( 0.0, 1.0 );\n\t\tvec2 texelSize = vec2( 1.0 ) / size;\n\t\tvec2 centroidUV = floor( uv * size + 0.5 ) / size;\n\t\tfloat lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n\t\tfloat lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n\t\tfloat rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n\t\tfloat rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n\t\tvec2 f = fract( uv * size + 0.5 );\n\t\tfloat a = mix( lb, lt, f.y );\n\t\tfloat b = mix( rb, rt, f.y );\n\t\tfloat c = mix( a, b, f.x );\n\t\treturn c;\n\t}\n\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n\t\tfloat shadow = 1.0;\n\t\tshadowCoord.xyz /= shadowCoord.w;\n\t\tshadowCoord.z += shadowBias;\n\t\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n\t\tbool inFrustum = all( inFrustumVec );\n\t\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n\t\tbool frustumTest = all( frustumTestVec );\n\t\tif ( frustumTest ) {\n\t\t#if defined( SHADOWMAP_TYPE_PCF )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tshadow = (\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n\t\t\t\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n\t\t\t) * ( 1.0 / 9.0 );\n\t\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n\t\t\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n\t\t\tfloat dx0 = - texelSize.x * shadowRadius;\n\t\t\tfloat dy0 = - texelSize.y * shadowRadius;\n\t\t\tfloat dx1 = + texelSize.x * shadowRadius;\n\t\t\tfloat dy1 = + texelSize.y * shadowRadius;\n\t\t\tshadow = (\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n\t\t\t\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy +

    var shadowmap_pars_vertex = "#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\t\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHTS ];\n\t\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\t\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHTS ];\n\t\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\t\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHTS ];\n\t\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n\t#endif\n#endif\n";

    var shadowmap_vertex = "#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\n\t}\n\t#endif\n#endif\n";

    var shadowmask_pars_fragment = "float getShadowMask() {\n\tfloat shadow = 1.0;\n\t#ifdef USE_SHADOWMAP\n\t#if NUM_DIR_LIGHTS > 0\n\tDirectionalLight directionalLight;\n\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\t\tdirectionalLight = directionalLights[ i ];\n\t\tshadow *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_SPOT_LIGHTS > 0\n\tSpotLight spotLight;\n\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\t\tspotLight = spotLights[ i ];\n\t\tshadow *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#if NUM_POINT_LIGHTS > 0\n\tPointLight pointLight;\n\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\t\tpointLight = pointLights[ i ];\n\t\tshadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n\t}\n\t#endif\n\t#endif\n\treturn shadow;\n}\n";

    var skinbase_vertex = "#ifdef USE_SKINNING\n\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\n\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\n\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\n\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif";

    var skinning_pars_vertex = "#ifdef USE_SKINNING\n\tuniform mat4 bindMatrix;\n\tuniform mat4 bindMatrixInverse;\n\t#ifdef BONE_TEXTURE\n\t\tuniform sampler2D boneTexture;\n\t\tuniform int boneTextureSize;\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tfloat j = i * 4.0;\n\t\t\tfloat x = mod( j, float( boneTextureSize ) );\n\t\t\tfloat y = floor( j / float( boneTextureSize ) );\n\t\t\tfloat dx = 1.0 / float( boneTextureSize );\n\t\t\tfloat dy = 1.0 / float( boneTextureSize );\n\t\t\ty = dy * ( y + 0.5 );\n\t\t\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n\t\t\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n\t\t\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n\t\t\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n\t\t\tmat4 bone = mat4( v1, v2, v3, v4 );\n\t\t\treturn bone;\n\t\t}\n\t#else\n\t\tuniform mat4 boneMatrices[ MAX_BONES ];\n\t\tmat4 getBoneMatrix( const in float i ) {\n\t\t\tmat4 bone = boneMatrices[ int(i) ];\n\t\t\treturn bone;\n\t\t}\n\t#endif\n#endif\n";

    var skinning_vertex = "#ifdef USE_SKINNING\n\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n\tvec4 skinned = vec4( 0.0 );\n\tskinned += boneMatX * skinVertex * skinWeight.x;\n\tskinned += boneMatY * skinVertex * skinWeight.y;\n\tskinned += boneMatZ * skinVertex * skinWeight.z;\n\tskinned += boneMatW * skinVertex * skinWeight.w;\n\ttransformed = ( bindMatrixInverse * skinned ).xyz;\n#endif\n";

    var skinnormal_vertex = "#ifdef USE_SKINNING\n\tmat4 skinMatrix = mat4( 0.0 );\n\tskinMatrix += skinWeight.x * boneMatX;\n\tskinMatrix += skinWeight.y * boneMatY;\n\tskinMatrix += skinWeight.z * boneMatZ;\n\tskinMatrix += skinWeight.w * boneMatW;\n\tskinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;\n\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n#endif\n";

    var specularmap_fragment = "float specularStrength;\n#ifdef USE_SPECULARMAP\n\tvec4 texelSpecular = texture2D( specularMap, vUv );\n\tspecularStrength = texelSpecular.r;\n#else\n\tspecularStrength = 1.0;\n#endif";

    var specularmap_pars_fragment = "#ifdef USE_SPECULARMAP\n\tuniform sampler2D specularMap;\n#endif";

    var tonemapping_fragment = "#if defined( TONE_MAPPING )\n  gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif\n";

    var tonemapping_pars_fragment = "#define saturate(a) clamp( a, 0.0, 1.0 )\nuniform float toneMappingExposure;\nuniform float toneMappingWhitePoint;\nvec3 LinearToneMapping( vec3 color ) {\n\treturn toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( color / ( vec3( 1.0 ) + color ) );\n}\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\nvec3 Uncharted2ToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\treturn saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n\tcolor *= toneMappingExposure;\n\tcolor = max( vec3( 0.0 ), color - 0.004 );\n\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\n";

    var 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\tvarying vec2 vUv;\n#endif";

    var 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\tvarying vec2 vUv;\n\tuniform vec4 offsetRepeat;\n#endif\n";

    var 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\tvUv = uv * offsetRepeat.zw + offsetRepeat.xy;\n#endif";

    var uv2_pars_fragment = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvarying vec2 vUv2;\n#endif";

    var uv2_pars_vertex = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tattribute vec2 uv2;\n\tvarying vec2 vUv2;\n#endif";

    var uv2_vertex = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n\tvUv2 = uv2;\n#endif";

    var worldpos_vertex = "#if defined( USE_ENVMAP ) || defined( PHONG ) || defined( PHYSICAL ) || defined( LAMBERT ) || defined ( USE_SHADOWMAP )\n\tvec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\n#endif\n";

    var cube_frag = "uniform samplerCube tCube;\nuniform float tFlip;\nuniform float opacity;\nvarying vec3 vWorldPosition;\n#include <common>\nvoid main() {\n\tgl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );\n\tgl_FragColor.a *= opacity;\n}\n";

    var cube_vert = "varying vec3 vWorldPosition;\n#include <common>\nvoid main() {\n\tvWorldPosition = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}\n";

    var depth_frag = "#if DEPTH_PACKING == 3200\n\tuniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( 1.0 );\n\t#if DEPTH_PACKING == 3200\n\t\tdiffuseColor.a = opacity;\n\t#endif\n\t#include <map_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <logdepthbuf_fragment>\n\t#if DEPTH_PACKING == 3200\n\t\tgl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity );\n\t#elif DEPTH_PACKING == 3201\n\t\tgl_FragColor = packDepthToRGBA( gl_FragCoord.z );\n\t#endif\n}\n";

    var depth_vert = "#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n}\n";

    var distanceRGBA_frag = "uniform vec3 lightPos;\nvarying vec4 vWorldPosition;\n#include <common>\n#include <packing>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n\t#include <clipping_planes_fragment>\n\tgl_FragColor = packDepthToRGBA( length( vWorldPosition.xyz - lightPos.xyz ) / 1000.0 );\n}\n";

    var distanceRGBA_vert = "varying vec4 vWorldPosition;\n#include <common>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <skinbase_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\tvWorldPosition = worldPosition;\n}\n";

    var equirect_frag = "uniform sampler2D tEquirect;\nuniform float tFlip;\nvarying vec3 vWorldPosition;\n#include <common>\nvoid main() {\n\tvec3 direction = normalize( vWorldPosition );\n\tvec2 sampleUV;\n\tsampleUV.y = saturate( tFlip * direction.y * -0.5 + 0.5 );\n\tsampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n\tgl_FragColor = texture2D( tEquirect, sampleUV );\n}\n";

    var equirect_vert = "varying vec3 vWorldPosition;\n#include <common>\nvoid main() {\n\tvWorldPosition = transformDirection( position, modelMatrix );\n\t#include <begin_vertex>\n\t#include <project_vertex>\n}\n";

    var linedashed_frag = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\n\t\tdiscard;\n\t}\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <color_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}\n";

    var linedashed_vert = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\tvLineDistance = scale * lineDistance;\n\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <fog_vertex>\n}\n";

    var meshbasic_frag = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\t#ifdef USE_LIGHTMAP\n\t\treflectedLight.indirectDiffuse += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n\t#else\n\t\treflectedLight.indirectDiffuse += vec3( 1.0 );\n\t#endif\n\t#include <aomap_fragment>\n\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\n\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\n\t#include <normal_flip>\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}\n";

    var meshbasic_vert = "#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <skinbase_vertex>\n\t#ifdef USE_ENVMAP\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <worldpos_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}\n";

    var meshlambert_frag = "uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <emissivemap_fragment>\n\treflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );\n\t#include <lightmap_fragment>\n\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n\t#ifdef DOUBLE_SIDED\n\t\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n\t#else\n\t\treflectedLight.directDiffuse = vLightFront;\n\t#endif\n\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n\t#include <normal_flip>\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n";

    var meshlambert_vert = "#define LAMBERT\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n\tvarying vec3 vLightBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <lights_lambert_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n";

    var meshphong_frag = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <gradientmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <specularmap_fragment>\n\t#include <normal_flip>\n\t#include <normal_fragment>\n\t#include <emissivemap_fragment>\n\t#include <lights_phong_fragment>\n\t#include <lights_template>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\t#include <envmap_fragment>\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n";

    var meshphong_vert = "#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n";

    var meshphysical_frag = "#define PHYSICAL\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n#ifndef STANDARD\n\tuniform float clearCoat;\n\tuniform float clearCoatRoughness;\n#endif\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <lights_pars>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n\tvec3 totalEmissiveRadiance = emissive;\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_flip>\n\t#include <normal_fragment>\n\t#include <emissivemap_fragment>\n\t#include <lights_physical_fragment>\n\t#include <lights_template>\n\t#include <aomap_fragment>\n\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n}\n";

    var meshphysical_vert = "#define PHYSICAL\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\tvViewPosition = - mvPosition.xyz;\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n";

    var normal_frag = "#define NORMAL\nuniform float opacity;\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <packing>\n#include <uv_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\nvoid main() {\n\t#include <logdepthbuf_fragment>\n\t#include <normal_flip>\n\t#include <normal_fragment>\n\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\n}\n";

    var normal_vert = "#define NORMAL\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\n\tvarying vec3 vViewPosition;\n#endif\n#ifndef FLAT_SHADED\n\tvarying vec3 vNormal;\n#endif\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\nvoid main() {\n\t#include <uv_vertex>\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n\tvNormal = normalize( transformedNormal );\n#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\n\tvViewPosition = - mvPosition.xyz;\n#endif\n}\n";

    var points_frag = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n\t#include <clipping_planes_fragment>\n\tvec3 outgoingLight = vec3( 0.0 );\n\tvec4 diffuseColor = vec4( diffuse, opacity );\n\t#include <logdepthbuf_fragment>\n\t#include <map_particle_fragment>\n\t#include <color_fragment>\n\t#include <alphatest_fragment>\n\toutgoingLight = diffuseColor.rgb;\n\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\n\t#include <premultiplied_alpha_fragment>\n\t#include <tonemapping_fragment>\n\t#include <encodings_fragment>\n\t#include <fog_fragment>\n}\n";

    var points_vert = "uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n\t#include <color_vertex>\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#ifdef USE_SIZEATTENUATION\n\t\tgl_PointSize = size * ( scale / - mvPosition.z );\n\t#else\n\t\tgl_PointSize = size;\n\t#endif\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n}\n";

    var shadow_frag = "uniform float opacity;\n#include <common>\n#include <packing>\n#include <bsdfs>\n#include <lights_pars>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\nvoid main() {\n\tgl_FragColor = vec4( 0.0, 0.0, 0.0, opacity * ( 1.0 - getShadowMask() ) );\n}\n";

    var shadow_vert = "#include <shadowmap_pars_vertex>\nvoid main() {\n\t#include <begin_vertex>\n\t#include <project_vertex>\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n}\n";




    var ShaderChunk = {
        alphamap_fragment: alphamap_fragment,
        alphamap_pars_fragment: alphamap_pars_fragment,
        alphatest_fragment: alphatest_fragment,
        aomap_fragment: aomap_fragment,
        aomap_pars_fragment: aomap_pars_fragment,
        begin_vertex: begin_vertex,
        beginnormal_vertex: beginnormal_vertex,
        bsdfs: bsdfs,
        bumpmap_pars_fragment: bumpmap_pars_fragment,
        clipping_planes_fragment: clipping_planes_fragment,
        clipping_planes_pars_fragment: clipping_planes_pars_fragment,
        clipping_planes_pars_vertex: clipping_planes_pars_vertex,
        clipping_planes_vertex: clipping_planes_vertex,
        color_fragment: color_fragment,
        color_pars_fragment: color_pars_fragment,
        color_pars_vertex: color_pars_vertex,
        color_vertex: color_vertex,
        common: common,
        cube_uv_reflection_fragment: cube_uv_reflection_fragment,
        defaultnormal_vertex: defaultnormal_vertex,
        displacementmap_pars_vertex: displacementmap_pars_vertex,
        displacementmap_vertex: displacementmap_vertex,
        emissivemap_fragment: emissivemap_fragment,
        emissivemap_pars_fragment: emissivemap_pars_fragment,
        encodings_fragment: encodings_fragment,
        encodings_pars_fragment: encodings_pars_fragment,
        envmap_fragment: envmap_fragment,
        envmap_pars_fragment: envmap_pars_fragment,
        envmap_pars_vertex: envmap_pars_vertex,
        envmap_vertex: envmap_vertex,
        fog_vertex: fog_vertex,
        fog_pars_vertex: fog_pars_vertex,
        fog_fragment: fog_fragment,
        fog_pars_fragment: fog_pars_fragment,
        gradientmap_pars_fragment: gradientmap_pars_fragment,
        lightmap_fragment: lightmap_fragment,
        lightmap_pars_fragment: lightmap_pars_fragment,
        lights_lambert_vertex: lights_lambert_vertex,
        lights_pars: lights_pars,
        lights_phong_fragment: lights_phong_fragment,
        lights_phong_pars_fragment: lights_phong_pars_fragment,
        lights_physical_fragment: lights_physical_fragment,
        lights_physical_pars_fragment: lights_physical_pars_fragment,
        lights_template: lights_template,
        logdepthbuf_fragment: logdepthbuf_fragment,
        logdepthbuf_pars_fragment: logdepthbuf_pars_fragment,
        logdepthbuf_pars_vertex: logdepthbuf_pars_vertex,
        logdepthbuf_vertex: logdepthbuf_vertex,
        map_fragment: map_fragment,
        map_pars_fragment: map_pars_fragment,
        map_particle_fragment: map_particle_fragment,
        map_particle_pars_fragment: map_particle_pars_fragment,
        metalnessmap_fragment: metalnessmap_fragment,
        metalnessmap_pars_fragment: metalnessmap_pars_fragment,
        morphnormal_vertex: morphnormal_vertex,
        morphtarget_pars_vertex: morphtarget_pars_vertex,
        morphtarget_vertex: morphtarget_vertex,
        normal_flip: normal_flip,
        normal_fragment: normal_fragment,
        normalmap_pars_fragment: normalmap_pars_fragment,
        packing: packing,
        premultiplied_alpha_fragment: premultiplied_alpha_fragment,
        project_vertex: project_vertex,
        dithering_fragment: dithering_fragment,
        dithering_pars_fragment: dithering_pars_fragment,
        roughnessmap_fragment: roughnessmap_fragment,
        roughnessmap_pars_fragment: roughnessmap_pars_fragment,
        shadowmap_pars_fragment: shadowmap_pars_fragment,
        shadowmap_pars_vertex: shadowmap_pars_vertex,
        shadowmap_vertex: shadowmap_vertex,
        shadowmask_pars_fragment: shadowmask_pars_fragment,
        skinbase_vertex: skinbase_vertex,
        skinning_pars_vertex: skinning_pars_vertex,
        skinning_vertex: skinning_vertex,
        skinnormal_vertex: skinnormal_vertex,
        specularmap_fragment: specularmap_fragment,
        specularmap_pars_fragment: specularmap_pars_fragment,
        tonemapping_fragment: tonemapping_fragment,
        tonemapping_pars_fragment: tonemapping_pars_fragment,
        uv_pars_fragment: uv_pars_fragment,
        uv_pars_vertex: uv_pars_vertex,
        uv_vertex: uv_vertex,
        uv2_pars_fragment: uv2_pars_fragment,
        uv2_pars_vertex: uv2_pars_vertex,
        uv2_vertex: uv2_vertex,
        worldpos_vertex: worldpos_vertex,

        cube_frag: cube_frag,
        cube_vert: cube_vert,
        depth_frag: depth_frag,
        depth_vert: depth_vert,
        distanceRGBA_frag: distanceRGBA_frag,
        distanceRGBA_vert: distanceRGBA_vert,
        equirect_frag: equirect_frag,
        equirect_vert: equirect_vert,
        linedashed_frag: linedashed_frag,
        linedashed_vert: linedashed_vert,
        meshbasic_frag: meshbasic_frag,
        meshbasic_vert: meshbasic_vert,
        meshlambert_frag: meshlambert_frag,
        meshlambert_vert: meshlambert_vert,
        meshphong_frag: meshphong_frag,
        meshphong_vert: meshphong_vert,
        meshphysical_frag: meshphysical_frag,
        meshphysical_vert: meshphysical_vert,
        normal_frag: normal_frag,
        normal_vert: normal_vert,
        points_frag: points_frag,
        points_vert: points_vert,
        shadow_frag: shadow_frag,
        shadow_vert: shadow_vert,

        none_frag: none_frag,
        none_vert:none_vert,
        normals_frag: normals_frag,
        normals_vert: normals_vert,
        texture_frag: texture_frag,
        texture_vert: texture_vert,
        texture_normals_frag: texture_normals_frag,
        texture_normals_vert: texture_normals_vert
    };

    ShaderChunk.parseIncludes = function (string) {

        var pattern = /#include +<([\w\d.]+)>/g;

        function replace(match, include) {

            var replace = ShaderChunk[include];

            if (replace === undefined) {

                throw new Error('Can not resolve #include <' + include + '>');

            }

            return ShaderChunk.parseIncludes(replace);

        }

        return string.replace(pattern, replace);

    }
    return ShaderChunk;
});
define('Core/FramebufferTexture',[], function () {

    /**
    *帧缓存纹理类，可以将一个mesh渲染到帧缓存并作为纹理提供给其他mesh。<br/>
    *需要配合{@link Cesium.MeshVisualizer}、{@link Cesium.Mesh}、{@link Cesium.MeshMaterial}使用。
    *@param {Cesium.Mesh}mesh
    *
    *@property {Cesium.Mesh}mesh
    *@property {Cesium.Texture}texture
    *
    *@constructor
    *@memberof Cesium
    *@example

        MeshVisualizer = Cesium.MeshVisualizer;
        Mesh = Cesium.Mesh;
        MeshMaterial = Cesium.MeshMaterial;
        FramebufferTexture = Cesium.FramebufferTexture;
        Shaders = VolumeRendering.Shaders;

        var center2 = Cesium.Cartesian3.fromDegrees(homePosition[0]+3.5, homePosition[1] , 50000);
        var modelMatrix2 = Cesium.Transforms.eastNorthUpToFixedFrame(center2);

        var meshVisualizer = new MeshVisualizer({
            modelMatrix: modelMatrix2,
            up: { y: 1 },
            scale: new Cesium.Cartesian3(2,2,2)
        });
        viewer.scene.primitives.add(meshVisualizer);

        var guiControls = new function () {
            this.model = 'bonsai';
            this.steps = 256.0;
            this.alphaCorrection = 1.0;
            this.color1 = "#00FA58";
            this.stepPos1 = 0.1;
            this.color2 = "#CC6600";
            this.stepPos2 = 0.7;
            this.color3 = "#F2F200";
            this.stepPos3 = 1.0;
        };
        function updateTransferFunction() {
            var canvas = document.createElement('canvas');
            canvas.height = 20;
            canvas.width = 256;

            var ctx = canvas.getContext('2d');

            var grd = ctx.createLinearGradient(0, 0, canvas.width - 1, canvas.height - 1);
            grd.addColorStop(guiControls.stepPos1, guiControls.color1);
            grd.addColorStop(guiControls.stepPos2, guiControls.color2);
            grd.addColorStop(guiControls.stepPos3, guiControls.color3);

            ctx.fillStyle = grd;
            ctx.fillRect(0, 0, canvas.width - 1, canvas.height - 1);

            return canvas;
        }

        var dimensions = new Cesium.Cartesian3(50000, 50000, 50000);
        var boxGeometry = Cesium.BoxGeometry.createGeometry(Cesium.BoxGeometry.fromDimensions({
            dimensions: dimensions,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY
        }));

        var materialFirstPass = new MeshMaterial({
            vertexShader: Shaders.vertexShaderFirstPass,
            fragmentShader: Shaders.fragmentShaderFirstPass,
            side: MeshMaterial.Sides.BACK,
            uniforms: {
                dimensions: dimensions
            }
        });
        var meshFirstPass = new Mesh(boxGeometry, materialFirstPass);
        var rtTexture = new FramebufferTexture(meshFirstPass);//这里使用FramebufferTexture
        var transferTexture = updateTransferFunction();
        var materialSecondPass = new MeshMaterial({
            vertexShader: Shaders.vertexShaderSecondPass,
            fragmentShader: Shaders.fragmentShaderSecondPass,
            side: MeshMaterial.Sides.FRONT,
            uniforms: {
                alpha: 1,
                dimensions: dimensions,
                tex: rtTexture,
                cubeTex: "./teapot.raw.png",
                transferTex: transferTexture,
                steps: guiControls.steps,
                alphaCorrection: guiControls.alphaCorrection
            }
        });

        var meshSecondPass = new Mesh(boxGeometry, materialSecondPass);
        meshVisualizer.add(meshSecondPass);
    */
    function FramebufferTexture(mesh,renderTarget) {
        this.mesh = mesh;
        this.texture = renderTarget;
    }

    return FramebufferTexture;
});
define('Core/LOD',[
    'Core/Rotation',
    'Core/RendererUtils'
], function (
    Rotation,
    RendererUtils
    ) {


    var defaultValue = Cesium.defaultValue;
    /**
    *
    *@param {Object|geometry}options
    *@param {Boolean}[options.show=true]
    *@param {Cesium.Cartesian3}[options.position]
    *@param {Cesium.Rotation}[options.rotation]
    *@param {Cesium.Cartesian3}[options.scale]
    *
    *@property {Boolean}show
    *@property {Cesium.Cartesian3}position
    *@property {Cesium.Rotation}rotation
    *@property {Cesium.Cartesian3}scale
    *@property {Boolean}needUpdate
    *
    *@constructor
    *@memberof Cesium
    *@example

        MeshVisualizer = Cesium.MeshVisualizer;
        Mesh = Cesium.Mesh;
        MeshMaterial = Cesium.MeshMaterial;
        LOD = Cesium.LOD;

        var center = Cesium.Cartesian3.fromDegrees(homePosition[0], homePosition[1], 50000);
        var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);

        var meshVisualizer = new MeshVisualizer({
            modelMatrix: modelMatrix,
            up: { z: 1 }
        });
        viewer.scene.primitives.add(meshVisualizer);


        var material = new MeshMaterial({
            defaultColor: "rgba(200,0,0,1.0)",
            wireframe: true,
            side: MeshMaterial.Sides.FRONT
        });
        var radius = 20000;
        var sphereL0 = Cesium.SphereGeometry.createGeometry(new Cesium.SphereGeometry({
            radius: radius,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY,
            stackPartitions:4,
            slicePartitions: 4
        }));
        var sphereL1 = Cesium.SphereGeometry.createGeometry(new Cesium.SphereGeometry({
            radius: radius,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY,
            stackPartitions: 8,
            slicePartitions: 8
        }));
        var sphereL2 = Cesium.SphereGeometry.createGeometry(new Cesium.SphereGeometry({
            radius: radius,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY,
            stackPartitions: 16,
            slicePartitions: 16
        }));
        var sphereL3 = Cesium.SphereGeometry.createGeometry(new Cesium.SphereGeometry({
            radius: radius,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY,
            stackPartitions: 32,
            slicePartitions: 32
        }));
        var sphereL4 = Cesium.SphereGeometry.createGeometry(new Cesium.SphereGeometry({
            radius: radius,
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY,
            stackPartitions: 64,
            slicePartitions: 64
        }));

        var geometries = [
					[sphereL4, 5],
					[sphereL3, 200],
					[sphereL2, 300],
					[sphereL1, 500],
					[sphereL0, 2000]
        ];

        var maxAvailableDistance = 10000000;

        var i, j, mesh, lod;
        var scale = new Cesium.Cartesian3(1, 1, 1);
        for (j = 0; j < 1000; j++) {

            lod = new LOD();

            for (i = 0; i < geometries.length; i++) {

                mesh = new Mesh(geometries[i][0], material);
                mesh.scale = scale;

                lod.addLevel(mesh, geometries[i][1] * 1000);
            }
            lod.maxAvailableDistance = maxAvailableDistance;
            lod.position.x = 1500000 * (0.5 - Math.random());
            lod.position.y = 1750000 * (0.5 - Math.random());
            lod.position.z = 130000 * (0.5 - Math.random());

            meshVisualizer.add(lod);

        }
    */
    function LOD(options) {

        options = defaultValue(options, {});

        this.uuid = Cesium.createGuid();
        this.show = defaultValue(options.show, true);
        this.maxAvailableDistance = defaultValue(options.maxAvailableDistance, Number.MAX_VALUE);
        this._position = defaultValue(options.position, new Cesium.Cartesian3(0, 0, 0));
        this._scale = defaultValue(options.scale, new Cesium.Cartesian3(1, 1, 1));
        this._rotation = defaultValue(options.rotation, { axis: new Cesium.Cartesian3(0, 0, 1), angle: 0 });
        this._rotation = new Rotation(this._rotation.axis, this._rotation.angle);
        this._boundingSphere = new Cesium.BoundingSphere();
        this._needsUpdate = false;
        this._modelMatrixNeedsUpdate = true;
        this._modelMatrix = new Cesium.Matrix4();
        Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY, this._modelMatrix);

        this._onNeedUpdateChanged = function () {
            this._modelMatrixNeedsUpdate = true;
        };
        this._rotation.paramChanged.removeEventListener(this._onNeedUpdateChanged);

        this._children = [];
        this._parent = null;
        this.type = 'LOD';

        Object.defineProperties(this, {
            levels: {
                enumerable: true,
                value: []
            }
        });

    }
    function removeByValue(arr, val) {
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] == val) {
                arr.splice(i, 1);
                break;
            }
        }
    }
    LOD.prototype = {

        constructor: LOD,
        /**
         *
         *@param {Number}x
         *@param {Number}y
         *@param {Number}z
         */
        setPosition: function (x, y, z) {
            var changed = false;
            if (arguments.length == 1) {
                if (typeof x == 'number') {
                    if (x != this._position.x) changed = true;
                    this._position.x = x;
                } else if (x instanceof Cesium.Cartesian3) {
                    if (x != this._position.x
                        || y != this._position.y
                        || z != this._position.z) {
                        changed = true;
                    }

                    this._position.x = x.x;
                    this._position.y = x.y;
                    this._position.z = x.z;
                }
            }
            if (arguments.length == 2 && typeof y == 'number') {
                if (y != this._position.y) changed = true;
                this._position.y = y;
            }
            if (arguments.length == 3 && typeof z == 'number') {
                if (z != this._position.z) changed = true;
                this._position.z = z;
            }
            if (changed) {
                this._modelMatrixNeedsUpdate = true;
            }
        },
        /**
         *
         *@param {Number}x
         *@param {Number}y
         *@param {Number}z
         */
        setScale: function (x, y, z) {
            var changed = false;
            if (arguments.length == 1) {
                if (typeof x == 'number') {
                    if (x != this._scale.x) changed = true;
                    this._scale.x = x;
                } else if (x instanceof Cesium.Cartesian3) {
                    if (x != this._scale.x
                        || y != this._scale.y
                        || z != this._scale.z) {
                        changed = true;
                    }

                    this._scale.x = x.x;
                    this._scale.y = x.y;
                    this._scale.z = x.z;
                }
            }
            if (arguments.length == 2 && typeof y == 'number') {
                if (y != this._scale.y) changed = true;
                this._scale.y = y;
            }
            if (arguments.length == 3 && typeof z == 'number') {
                if (z != this._scale.z) changed = true;
                this._scale.z = z;
            }
            if (changed) {
                this._modelMatrixNeedsUpdate = true;
            }
        },

        /**
        *@param {Cesium.Mesh}mesh
        *@param {Number}distance
        */
        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 });
            object.parent = this;
            this._children.push(object);
            if (this.levels[0].object.geometry) {
                this._boundingSphere.radius = this.levels[0].object.geometry.boundingSphere.radius;
            } else if (this.levels[0].object.boundingSphere) {
                this._boundingSphere.radius = this.levels[0].object.boundingSphere.radius;
            }
        },
        update: function () {

            var actualPosition = new Cesium.Cartesian3();

            return function update(parentModelMatrix, frameState) {

                var levels = this.levels;

                if (levels.length > 1) {
                    if (this._modelMatrixNeedsUpdate) {

                        RendererUtils.computeModelMatrix(
                           parentModelMatrix,
                           this.position,
                           this.rotation,
                           this.scale,
                           this.modelMatrix
                       );

                        this._modelMatrixNeedsUpdate = false;
                    }

                    Cesium.Matrix4.getTranslation(this.modelMatrix, actualPosition);

                    Cesium.Cartesian3.clone(actualPosition, this._boundingSphere.center);

                    var bs = this._boundingSphere;
                    var distance = Math.max(0.0, Cesium.Cartesian3.distance(bs.center, frameState.camera.positionWC) - bs.radius);

                    var show = this.maxAvailableDistance > distance;

                    show = show && frameState.cullingVolume.computeVisibility(this._boundingSphere) !== Cesium.Intersect.OUTSIDE;
                    levels[0].object.show = show;

                    for (var i = 1, l = levels.length; i < l; i++) {

                        if (distance >= levels[i].distance) {

                            levels[i - 1].object.show = false;
                            levels[i].object.show = show;

                        } else {

                            break;

                        }

                    }

                    for (; i < l; i++) {

                        levels[i].object.show = false;

                    }
                }
            };

        }(),
        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;

        }
    };

    Object.defineProperties(LOD.prototype, {
        modelMatrix: {
            get: function () {
                return this._modelMatrix;
            }
        },
        parent: {
            get: function () {
                return this._parent;
            },
            set: function (val) {
                if (val && ((val._children && Array.isArray(val._children)) || (val.children && Array.isArray(val.children)))) {

                    if (this._parent && this._parent != val) {
                        var children = this._parent._children ? this._parent._children : this._parent.children;
                        if (Array.isArray(children)) {
                            removeByValue(children, this);
                        }
                    }
                    this._parent = val;
                    if (typeof this._parent.add === 'function') {
                        this._parent.add(this);
                    } else {
                        var children = val._children ? val._children : val.children;
                        children.push(this);
                    }
                }
                this._needsUpdate = true;
            }
        },
        children: {
            get: function () {
                return this._children;
            },
            set: function (val) {
                this._children = val;
                this._needsUpdate = true;
            }
        },
        needsUpdate: {
            get: function () {
                return this._needsUpdate;
            },
            set: function (val) {
                this._needsUpdate = val;
            }
        },
        rotation: {
            get: function () {
                return this._rotation;
            },
            set: function (val) {
                if (val != this._rotation) {
                    this._rotation = val;
                    this._needUpdate = true;
                }
                this._rotation.paramChanged.removeEventListener(this._onNeedUpdateChanged);
                this._rotation = val;
                this._rotation.paramChanged.addEventListener(this._onNeedUpdateChanged);
            }
        },
        position: {
            get: function () {
                return this._position;
            },
            set: function (val) {
                if (val.x != this._position.x || val.y != this._position.y || val.z != this._position.z) {
                    this._position = val;
                    this._needsUpdate = true;
                }
                this._position = val;
            }
        },
        scale: {
            get: function () {
                return this._scale;
            },
            set: function (val) {
                if (val.x != this._scale.x || val.y != this._scale.y || val.z != this._scale.z) {
                    this._scale = val;
                    this._needsUpdate = true;
                }
                this._scale = val;
            }
        }
    });

    return LOD;

});
define('Core/ArrowGeometry',[
    'Core/GeometryUtils'
], function (
    GeometryUtils
    ) {

    /**
    *
      <pre><code>
              +            ——
            +   +           |
          +       +     headLength
        +           +       |
      ++++headWidth++++   ——
            +  +            |
            +  +            |
            +  +            |
            +  +          length
            +  +            |
            +  +            |
            +  +            |
            ++++           ——
            width

        </code> </pre>
    *@param {Object}[options]
    *@param {Number}[options.length=50000]
    *@param {Number}[options.width=250]
    *@param {Number}[options.headLength=5000]
    *@param {Number}[options.headWidth=1000]
    *@param {Boolean}[options.reverse=false]
    *
    *@property {Number}length
    *@property {Number}width
    *@property {Number}headLength
    *@property {Number}headWidth
    *@property {Boolean}reverse
    *
    *@constructor
    *@memberof Cesium
    */
    function ArrowGeometry(options) {
        options = Cesium.defaultValue(options, {});
        this.length = Cesium.defaultValue(options.length, 50000);
        this.width = Cesium.defaultValue(options.width, 125);
        this.headLength = Cesium.defaultValue(options.headLength, 5000);
        this.headWidth = Cesium.defaultValue(options.headWidth, 1000);
        this.reverse = Cesium.defaultValue(options.reverse, false);
    }

    /**
    *
    *@param {Cesium.ArrowGeometry}
    *@return {Cesium.Geometry}
    */
    ArrowGeometry.createGeometry = function (arrowGeometry) {
        var length = arrowGeometry.length;
        var width = arrowGeometry.width;
        var headLength = arrowGeometry.headLength;
        var headWidth = arrowGeometry.headWidth;
        var reverse = arrowGeometry.reverse;

        var line = Cesium.CylinderGeometry.createGeometry(new Cesium.CylinderGeometry({
            length: length,
            topRadius: width,
            bottomRadius: width,
        }));
        var arrow;
        if (reverse) {
            arrow = Cesium.CylinderGeometry.createGeometry(new Cesium.CylinderGeometry({
                length: headLength,
                topRadius: headWidth,
                bottomRadius: 0,
            }));
            GeometryUtils.translate(arrow, [0, 0, -(length + headLength) / 2]);
        } else {
            arrow = Cesium.CylinderGeometry.createGeometry(new Cesium.CylinderGeometry({
                length: headLength,
                topRadius: 0,
                bottomRadius: headWidth,
            }));
            GeometryUtils.translate(arrow, [0, 0, (length + headLength) / 2]);
        }

        var lineWithArrow = GeometryUtils.mergeGeometries([line, arrow]);

        return lineWithArrow;
    }
    return ArrowGeometry;
});
define('Core/PlaneGeometry',[],function () {

    /**
    *
      <pre><code>
        p1++++++++++++p4
        +          +  +
        +       +     +
        +     +       +
        +   +         +
        + +           +
        p2++++++++++++p3
        </code> </pre>
    *@param {Object}options
    *@param {Array<Number|Cesium.Cartesian3>}options.positions [p1,p2,p3,p4]或者[p1.x,p1.y,p1.z,p2.x,...,p4.z]
    *
    *@property {Array<Number|Cesium.Cartesian3>}positions
    *
    *@constructor
    *@memberof Cesium
    */
    function PlaneGeometry(options) {//positions, widthSegments, heightSegments) {
        this.type = 'PlaneGeometry';
        if (!options || !options.positions) {
            throw new Error("缺少positions参数");
        }
        if (options.positions.length != 4 && options.positions.length / 3 != 4) {
            throw new Error("positions参数必须包含四个顶点的位置坐标");
        }
        this.positions = options.positions;

    }
    /**
    *
    *@param {Cesium.PlaneGeometry}
    *@return {Cesium.Geometry}
    */
    PlaneGeometry.createGeometry = function (planeGeometry) {
        var positions = planeGeometry.positions;

        var positionsVal;
        if (Array.isArray(positions)) {
            if (positions[0] instanceof Cesium.Cartesian3) {
                positionsVal = new Float32Array(12);
                for (var i = 0; i < positions.length; i++) {
                    var p = positions[i];
                    positionsVal[i * 3] = p.x;
                    positionsVal[i * 3 + 1] = p.y;
                    positionsVal[i * 3 + 2] = p.z;
                }
            } else if (typeof positions[0] === 'number') {
                positionsVal = new Float32Array(positionsVal);
            } else {
                throw new Error("positions参数有误");
            }
        } else {
            throw new Error("positions参数必须是数组类型");
        }
        var indices = new Int32Array([0, 1, 3, 1, 2, 3]);
        var attributes = {
            position: new Cesium.GeometryAttribute({
                componentDatatype: Cesium.ComponentDatatype.DOUBLE,
                componentsPerAttribute: 3,
                values: positions
            })
        };
        var bs = Cesium.BoundingSphere.fromVertices(positions);
        var geo = new Cesium.Geometry({
            attributes: attributes,
            indices: new Int32Array(indices),
            primitiveType: Cesium.PrimitiveType.TRIANGLES,
            boundingSphere: bs
        });
        return geo;
    }
    return PlaneGeometry
});
define('Core/ReferenceMesh',[
    'Core/ArrowGeometry',
    'Core/PlaneGeometry',
    'Core/Mesh',
    'Core/MeshMaterial',
    'Core/Rotation',
    'Core/RendererUtils'
], function (
    ArrowGeometry,
    PlaneGeometry,
    Mesh,
    MeshMaterial,
    Rotation,
    RendererUtils
    ) {
    var defaultValue = Cesium.defaultValue;
    /**
    *
    *@param {Object}[options]
    *@param {Cesium.ArrowGeometry}[options.axisParameter]
    *@param {Boolean}[options.show=true]
    *@param {Cesium.Cartesian3}[options.position]
    *@param {Cesium.VolumeRendering.Rotation}[options.rotation]
    *@param {Cesium.Cartesian3}[options.scale]
    *
    *@property {Boolean}show
    *@property {Cesium.Cartesian3}position
    *@property {Cesium.Rotation}rotation
    *@property {Cesium.Cartesian3}scale
    *@property {Boolean}needUpdate
    *
    *@constructor
    *@memberof Cesium
    */
    function ReferenceMesh(options) {
        options = Cesium.defaultValue(options, {});
        this._axisParameter = new ArrowGeometry(options.axisParameter);
        this._axisParameterY = new ArrowGeometry(options.axisParameter);
        this._axisParameterY.reverse = true;

        var materialZ = new MeshMaterial({
            defaultColor: "rgba(255,0,0,1)",
            wireframe: false,
            side: MeshMaterial.Sides.DOUBLE,
            translucent: false,

        });
        var materialY = new MeshMaterial({
            defaultColor: "rgba(0,255,0,1)",
            wireframe: false,
            side: MeshMaterial.Sides.DOUBLE,
            translucent: true,

        });
        var materialX = new MeshMaterial({
            defaultColor: "rgba(0,0,255,1)",
            wireframe: false,
            side: MeshMaterial.Sides.DOUBLE,
            translucent: false,

        });

        var axisLine = ArrowGeometry.createGeometry(new ArrowGeometry(this._axisParameter));
        var axisLineY = ArrowGeometry.createGeometry(new ArrowGeometry(this._axisParameterY));

        var meshZ = new Mesh(axisLine, materialZ);
        var meshY = new Mesh(axisLineY, materialY);
        var meshX = new Mesh(axisLine, materialX);
        meshZ.position.z = this._axisParameter.length / 2;

        meshY.position.y = -this._axisParameter.length / 2;
        meshY.rotation.axis.y = 1;
        meshY.rotation.angle = -180;

        meshX.position.x = this._axisParameter.length / 2;
        meshX.rotation.axis.x = 1;
        meshX.rotation.angle = -180;

        meshX.parent = this;
        meshY.parent = this;
        meshZ.parent = this;

        this._children = [meshX, meshY, meshZ];
        this.x = meshX;
        this.y = meshY;
        this.z = meshZ;

        this.uuid = Cesium.createGuid();
        this.show = defaultValue(options.show, true);
        this._position = defaultValue(options.position, new Cesium.Cartesian3(0, 0, 0));
        this._scale = defaultValue(options.scale, new Cesium.Cartesian3(1, 1, 1));
        this._rotation = defaultValue(options.rotation, { axis: new Cesium.Cartesian3(0, 0, 1), angle: 0 });
        this._rotation = new Rotation(this._rotation.axis, this._rotation.angle);
        this._needsUpdate = true;
        this._modelMatrixNeedsUpdate = true;
        this._modelMatrix = new Cesium.Matrix4();
        Cesium.Matrix4.clone(Cesium.Matrix4.IDENTITY, this._modelMatrix);

        this._onNeedUpdateChanged = function () {
            this._modelMatrixNeedsUpdate = true;
        };
        this._rotation.paramChanged.removeEventListener(this._onNeedUpdateChanged);
        this._parent = null;

    }
    function removeByValue(arr, val) {
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] == val) {
                arr.splice(i, 1);
                break;
            }
        }
    }
    Object.defineProperties(ReferenceMesh.prototype, {
        modelMatrix: {
            get: function () {
                return this._modelMatrix;
            }
        },
        parent: {
            get: function () {
                return this._parent;
            },
            set: function (val) {
                if (val && ((val._children && Array.isArray(val._children)) || (val.children && Array.isArray(val.children)))) {

                    if (this._parent && this._parent != val) {
                        var children = this._parent._children ? this._parent._children : this._parent.children;
                        if (Array.isArray(children)) {
                            removeByValue(children, this);
                        }
                    }
                    this._parent = val;
                    if (typeof this._parent.add === 'function') {
                        this._parent.add(this);
                    } else {
                        var children = val._children ? val._children : val.children;
                        children.push(this);
                    }
                }
                this.modelMatrixNeedsUpdate = true;
            }
        },
        modelMatrixNeedsUpdate: {
            get: function () {
                return this._modelMatrixNeedsUpdate;
            },
            set: function (val) {
                this._modelMatrixNeedsUpdate = val;
                if (this._modelMatrixNeedsUpdate) {
                    Mesh.traverse(this, function (mesh) {
                        mesh._modelMatrixNeedsUpdate = val;
                    });
                }
            }
        },
        children: {
            get: function () {
                return this._children;
            }
        },
        needsUpdate: {
            get: function () {
                return this._needsUpdate;
            },
            set: function (val) {
                this._needsUpdate = val;
            }
        },
        rotation: {
            get: function () {
                return this._rotation;
            },
            set: function (val) {
                if (val != this._rotation) {
                    this._rotation = val;
                    this.modelMatrixNeedsUpdate = true;
                }
                this._rotation.paramChanged.removeEventListener(this._onNeedUpdateChanged);
                this._rotation = val;
                this._rotation.paramChanged.addEventListener(this._onNeedUpdateChanged);
            }
        },
        position: {
            get: function () {
                return this._position;
            },
            set: function (val) {
                if (val.x != this._position.x || val.y != this._position.y || val.z != this._position.z) {
                    this._position = val;
                    this.modelMatrixNeedsUpdate = true;
                }
                this._position = val;
            }
        },
        scale: {
            get: function () {
                return this._scale;
            },
            set: function (val) {
                if (val.x != this._scale.x || val.y != this._scale.y || val.z != this._scale.z) {
                    this._scale = val;
                    this.modelMatrixNeedsUpdate = true;
                }
                this._scale = val;
            }
        }
    });

    /**
    *
    *@param {Cesium.Matrix4}meshVisulizerModelMatrix
    *@param {Cesium.FrameState}frameState
    */
    ReferenceMesh.prototype.update = function (parentModelMatrix, frameState) {

        if (this._modelMatrixNeedsUpdate || this._needsUpdate) {

            RendererUtils.computeModelMatrix(
               parentModelMatrix,
               this.position,
               this.rotation,
               this.scale,
               this.modelMatrix
           );

            this._modelMatrixNeedsUpdate = false;
        }
    }

    return ReferenceMesh;
});
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */



function TIFFParser() {
	this.tiffDataView = undefined;
	this.littleEndian = undefined;
	this.fileDirectories = [];
};

TIFFParser.prototype = {
	isLittleEndian: function () {
		// Get byte order mark.
		var BOM = this.getBytes(2, 0);

		// Find out the endianness.
		if (BOM === 0x4949) {
			this.littleEndian = true;
		} else if (BOM === 0x4D4D) {
			this.littleEndian = false;
		} else {
			console.log( BOM );
			throw TypeError("Invalid byte order value.");
		}

		return this.littleEndian;
	},

	hasTowel: function () {
		// Check for towel.
		if (this.getBytes(2, 2) !== 42) {
			throw RangeError("You forgot your towel!");
			return false;
		}

		return true;
	},

	getFieldTagName: function (fieldTag) {
		// See: http://www.digitizationguidelines.gov/guidelines/TIFF_Metadata_Final.pdf
		// See: http://www.digitalpreservation.gov/formats/content/tiff_tags.shtml
		var fieldTagNames = {
			// TIFF Baseline
			0x013B: 'Artist',
			0x0102: 'BitsPerSample',
			0x0109: 'CellLength',
			0x0108: 'CellWidth',
			0x0140: 'ColorMap',
			0x0103: 'Compression',
			0x8298: 'Copyright',
			0x0132: 'DateTime',
			0x0152: 'ExtraSamples',
			0x010A: 'FillOrder',
			0x0121: 'FreeByteCounts',
			0x0120: 'FreeOffsets',
			0x0123: 'GrayResponseCurve',
			0x0122: 'GrayResponseUnit',
			0x013C: 'HostComputer',
			0x010E: 'ImageDescription',
			0x0101: 'ImageLength',
			0x0100: 'ImageWidth',
			0x010F: 'Make',
			0x0119: 'MaxSampleValue',
			0x0118: 'MinSampleValue',
			0x0110: 'Model',
			0x00FE: 'NewSubfileType',
			0x0112: 'Orientation',
			0x0106: 'PhotometricInterpretation',
			0x011C: 'PlanarConfiguration',
			0x0128: 'ResolutionUnit',
			0x0116: 'RowsPerStrip',
			0x0115: 'SamplesPerPixel',
			0x0131: 'Software',
			0x0117: 'StripByteCounts',
			0x0111: 'StripOffsets',
			0x00FF: 'SubfileType',
			0x0107: 'Threshholding',
			0x011A: 'XResolution',
			0x011B: 'YResolution',

			// TIFF Extended
			0x0146: 'BadFaxLines',
			0x0147: 'CleanFaxData',
			0x0157: 'ClipPath',
			0x0148: 'ConsecutiveBadFaxLines',
			0x01B1: 'Decode',
			0x01B2: 'DefaultImageColor',
			0x010D: 'DocumentName',
			0x0150: 'DotRange',
			0x0141: 'HalftoneHints',
			0x015A: 'Indexed',
			0x015B: 'JPEGTables',
			0x011D: 'PageName',
			0x0129: 'PageNumber',
			0x013D: 'Predictor',
			0x013F: 'PrimaryChromaticities',
			0x0214: 'ReferenceBlackWhite',
			0x0153: 'SampleFormat',
			0x022F: 'StripRowCounts',
			0x014A: 'SubIFDs',
			0x0124: 'T4Options',
			0x0125: 'T6Options',
			0x0145: 'TileByteCounts',
			0x0143: 'TileLength',
			0x0144: 'TileOffsets',
			0x0142: 'TileWidth',
			0x012D: 'TransferFunction',
			0x013E: 'WhitePoint',
			0x0158: 'XClipPathUnits',
			0x011E: 'XPosition',
			0x0211: 'YCbCrCoefficients',
			0x0213: 'YCbCrPositioning',
			0x0212: 'YCbCrSubSampling',
			0x0159: 'YClipPathUnits',
			0x011F: 'YPosition',

			// EXIF
			0x9202: 'ApertureValue',
			0xA001: 'ColorSpace',
			0x9004: 'DateTimeDigitized',
			0x9003: 'DateTimeOriginal',
			0x8769: 'Exif IFD',
			0x9000: 'ExifVersion',
			0x829A: 'ExposureTime',
			0xA300: 'FileSource',
			0x9209: 'Flash',
			0xA000: 'FlashpixVersion',
			0x829D: 'FNumber',
			0xA420: 'ImageUniqueID',
			0x9208: 'LightSource',
			0x927C: 'MakerNote',
			0x9201: 'ShutterSpeedValue',
			0x9286: 'UserComment',

			// IPTC
			0x83BB: 'IPTC',

			// ICC
			0x8773: 'ICC Profile',

			// XMP
			0x02BC: 'XMP',

			// GDAL
			0xA480: 'GDAL_METADATA',
			0xA481: 'GDAL_NODATA',

			// Photoshop
			0x8649: 'Photoshop',
		};

		var fieldTagName;

		if (fieldTag in fieldTagNames) {
			fieldTagName = fieldTagNames[fieldTag];
		} else {
			//console.log( "Unknown Field Tag:", fieldTag);
			fieldTagName = "Tag" + fieldTag;
		}

		return fieldTagName;
	},

	getFieldTypeName: function (fieldType) {
		var fieldTypeNames = {
			0x0001: 'BYTE',
			0x0002: 'ASCII',
			0x0003: 'SHORT',
			0x0004: 'LONG',
			0x0005: 'RATIONAL',
			0x0006: 'SBYTE',
			0x0007: 'UNDEFINED',
			0x0008: 'SSHORT',
			0x0009: 'SLONG',
			0x000A: 'SRATIONAL',
			0x000B: 'FLOAT',
			0x000C: 'DOUBLE',
		};

		var fieldTypeName;

		if (fieldType in fieldTypeNames) {
			fieldTypeName = fieldTypeNames[fieldType];
		}

		return fieldTypeName;
	},

	getFieldTypeLength: function (fieldTypeName) {
		var fieldTypeLength;

		if (['BYTE', 'ASCII', 'SBYTE', 'UNDEFINED'].indexOf(fieldTypeName) !== -1) {
			fieldTypeLength = 1;
		} else if (['SHORT', 'SSHORT'].indexOf(fieldTypeName) !== -1) {
			fieldTypeLength = 2;
		} else if (['LONG', 'SLONG', 'FLOAT'].indexOf(fieldTypeName) !== -1) {
			fieldTypeLength = 4;
		} else if (['RATIONAL', 'SRATIONAL', 'DOUBLE'].indexOf(fieldTypeName) !== -1) {
			fieldTypeLength = 8;
		}

		return fieldTypeLength;
	},

	getBits: function (numBits, byteOffset, bitOffset) {
		bitOffset = bitOffset || 0;
		var extraBytes = Math.floor(bitOffset / 8);
		var newByteOffset = byteOffset + extraBytes;
		var totalBits = bitOffset + numBits;
		var shiftRight = 32 - numBits;

		if (totalBits <= 0) {
			console.log( numBits, byteOffset, bitOffset );
			throw RangeError("No bits requested");
		} else if (totalBits <= 8) {
			var shiftLeft = 24 + bitOffset;
			var rawBits = this.tiffDataView.getUint8(newByteOffset, this.littleEndian);
		} else if (totalBits <= 16) {
			var shiftLeft = 16 + bitOffset;
			var rawBits = this.tiffDataView.getUint16(newByteOffset, this.littleEndian);
		} else if (totalBits <= 32) {
			var shiftLeft = bitOffset;
			var rawBits = this.tiffDataView.getUint32(newByteOffset, this.littleEndian);
		} else {
			console.log( numBits, byteOffset, bitOffset );
			throw RangeError("Too many bits requested");
		}

		var chunkInfo = {
			'bits': ((rawBits << shiftLeft) >>> shiftRight),
			'byteOffset': newByteOffset + Math.floor(totalBits / 8),
			'bitOffset': totalBits % 8,
		};

		return chunkInfo;
	},

	getBytes: function (numBytes, offset) {
		if (numBytes <= 0) {
			console.log( numBytes, offset );
			throw RangeError("No bytes requested");
		} else if (numBytes <= 1) {
			return this.tiffDataView.getUint8(offset, this.littleEndian);
		} else if (numBytes <= 2) {
			return this.tiffDataView.getUint16(offset, this.littleEndian);
		} else if (numBytes <= 3) {
			return this.tiffDataView.getUint32(offset, this.littleEndian) >>> 8;
		} else if (numBytes <= 4) {
			return this.tiffDataView.getUint32(offset, this.littleEndian);
		} else {
			console.log( numBytes, offset );
			throw RangeError("Too many bytes requested");
		}
	},

	getFieldValues: function (fieldTagName, fieldTypeName, typeCount, valueOffset) {
		var fieldValues = [];

		var fieldTypeLength = this.getFieldTypeLength(fieldTypeName);
		var fieldValueSize = fieldTypeLength * typeCount;

		if (fieldValueSize <= 4) {
			// The value is stored at the big end of the valueOffset.
			if (this.littleEndian === false) {
				var value = valueOffset >>> ((4 - fieldTypeLength) * 8);
			} else {
				var value = valueOffset;
			}

			fieldValues.push(value);
		} else {
			for (var i = 0; i < typeCount; i++) {
				var indexOffset = fieldTypeLength * i;

				if (fieldTypeLength >= 8) {
					if (['RATIONAL', 'SRATIONAL'].indexOf(fieldTypeName) !== -1) {
						// Numerator
						fieldValues.push(this.getBytes(4, valueOffset + indexOffset));
						// Denominator
						fieldValues.push(this.getBytes(4, valueOffset + indexOffset + 4));
//					} else if (['DOUBLE'].indexOf(fieldTypeName) !== -1) {
//						fieldValues.push(this.getBytes(4, valueOffset + indexOffset) + this.getBytes(4, valueOffset + indexOffset + 4));
					} else {
						console.log( fieldTypeName, typeCount, fieldValueSize );
						throw TypeError("Can't handle this field type or size");
					}
				} else {
					fieldValues.push(this.getBytes(fieldTypeLength, valueOffset + indexOffset));
				}
			}
		}

		if (fieldTypeName === 'ASCII') {
			fieldValues.forEach(function(e, i, a) { a[i] = String.fromCharCode(e); });
		}

		return fieldValues;
	},

	clampColorSample: function(colorSample, bitsPerSample) {
		var multiplier = Math.pow(2, 8 - bitsPerSample);

		return Math.floor((colorSample * multiplier) + (multiplier - 1));
	},

	makeRGBAFillValue: function(r, g, b, a) {
		if(typeof a === 'undefined') {
			a = 1.0;
		}
		return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")";
	},

	parseFileDirectory: function (byteOffset) {
		var numDirEntries = this.getBytes(2, byteOffset);

		var tiffFields = [];

		for (var i = byteOffset + 2, entryCount = 0; entryCount < numDirEntries; i += 12, entryCount++) {
			var fieldTag = this.getBytes(2, i);
			var fieldType = this.getBytes(2, i + 2);
			var typeCount = this.getBytes(4, i + 4);
			var valueOffset = this.getBytes(4, i + 8);

			var fieldTagName = this.getFieldTagName( fieldTag );
			var fieldTypeName = this.getFieldTypeName( fieldType );

			var fieldValues = this.getFieldValues(fieldTagName, fieldTypeName, typeCount, valueOffset);

			tiffFields[fieldTagName] = { 'type': fieldTypeName, 'values': fieldValues };
		}

		this.fileDirectories.push( tiffFields );

		var nextIFDByteOffset = this.getBytes(4, i);

		if (nextIFDByteOffset === 0x00000000) {
			return this.fileDirectories;
		} else {
			return this.parseFileDirectory(nextIFDByteOffset);
		}
	},

	parseTIFF: function (tiffArrayBuffer, canvas) {
		canvas = canvas || document.createElement('canvas');

		this.tiffDataView = new DataView(tiffArrayBuffer);
		this.canvas = canvas;

		this.littleEndian = this.isLittleEndian(this.tiffDataView);

		if (!this.hasTowel(this.tiffDataView, this.littleEndian)) {
			return;
		}

		var firstIFDByteOffset = this.getBytes(4, 4);

		this.fileDirectories = this.parseFileDirectory(firstIFDByteOffset);

		var fileDirectory = this.fileDirectories[0];

		//console.log( fileDirectory );

		var imageWidth = fileDirectory.ImageWidth.values[0];
		var imageLength = fileDirectory.ImageLength.values[0];

		this.canvas.width = imageWidth;
		this.canvas.height = imageLength;

		var strips = [];

		var compression = (fileDirectory.Compression) ? fileDirectory.Compression.values[0] : 1;

		var samplesPerPixel = fileDirectory.SamplesPerPixel.values[0];

		var sampleProperties = [];

		var bitsPerPixel = 0;
		var hasBytesPerPixel = false;

		fileDirectory.BitsPerSample.values.forEach(function(bitsPerSample, i, bitsPerSampleValues) {
			sampleProperties[i] = {
				'bitsPerSample': bitsPerSample,
				'hasBytesPerSample': false,
				'bytesPerSample': undefined,
			};

			if ((bitsPerSample % 8) === 0) {
				sampleProperties[i].hasBytesPerSample = true;
				sampleProperties[i].bytesPerSample = bitsPerSample / 8;
			}

			bitsPerPixel += bitsPerSample;
		}, this);

		if ((bitsPerPixel % 8) === 0) {
			hasBytesPerPixel = true;
			var bytesPerPixel = bitsPerPixel / 8;
		}

		var stripOffsetValues = fileDirectory.StripOffsets.values;
		var numStripOffsetValues = stripOffsetValues.length;

		// StripByteCounts is supposed to be required, but see if we can recover anyway.
		if (fileDirectory.StripByteCounts) {
			var stripByteCountValues = fileDirectory.StripByteCounts.values;
		} else {
			console.log("Missing StripByteCounts!");

			// Infer StripByteCounts, if possible.
			if (numStripOffsetValues === 1) {
				var stripByteCountValues = [Math.ceil((imageWidth * imageLength * bitsPerPixel) / 8)];
			} else {
				throw Error("Cannot recover from missing StripByteCounts");
			}
		}

		// Loop through strips and decompress as necessary.
		for (var i = 0; i < numStripOffsetValues; i++) {
			var stripOffset = stripOffsetValues[i];
			strips[i] = [];

			var stripByteCount = stripByteCountValues[i];

			// Loop through pixels.
			for (var byteOffset = 0, bitOffset = 0, jIncrement = 1, getHeader = true, pixel = [], numBytes = 0, sample = 0, currentSample = 0; byteOffset < stripByteCount; byteOffset += jIncrement) {
				// Decompress strip.
				switch (compression) {
					// Uncompressed
					case 1:
						// Loop through samples (sub-pixels).
						for (var m = 0, pixel = []; m < samplesPerPixel; m++) {
							if (sampleProperties[m].hasBytesPerSample) {
								// XXX: This is wrong!
								var sampleOffset = sampleProperties[m].bytesPerSample * m;

								pixel.push(this.getBytes(sampleProperties[m].bytesPerSample, stripOffset + byteOffset + sampleOffset));
							} else {
								var sampleInfo = this.getBits(sampleProperties[m].bitsPerSample, stripOffset + byteOffset, bitOffset);

								pixel.push(sampleInfo.bits);

								byteOffset = sampleInfo.byteOffset - stripOffset;
								bitOffset = sampleInfo.bitOffset;

								throw RangeError("Cannot handle sub-byte bits per sample");
							}
						}

						strips[i].push(pixel);

						if (hasBytesPerPixel) {
							jIncrement = bytesPerPixel;
						} else {
							jIncrement = 0;

							throw RangeError("Cannot handle sub-byte bits per pixel");
						}
					break;

					// CITT Group 3 1-Dimensional Modified Huffman run-length encoding
					case 2:
						// XXX: Use PDF.js code?
					break;

					// Group 3 Fax
					case 3:
						// XXX: Use PDF.js code?
					break;

					// Group 4 Fax
					case 4:
						// XXX: Use PDF.js code?
					break;

					// LZW
					case 5:
						// XXX: Use PDF.js code?
					break;

					// Old-style JPEG (TIFF 6.0)
					case 6:
						// XXX: Use PDF.js code?
					break;

					// New-style JPEG (TIFF Specification Supplement 2)
					case 7:
						// XXX: Use PDF.js code?
					break;

					// PackBits
					case 32773:
						// Are we ready for a new block?
						if (getHeader) {
							getHeader = false;

							var blockLength = 1;
							var iterations = 1;

							// The header byte is signed.
							var header = this.tiffDataView.getInt8(stripOffset + byteOffset, this.littleEndian);

							if ((header >= 0) && (header <= 127)) { // Normal pixels.
								blockLength = header + 1;
							} else if ((header >= -127) && (header <= -1)) { // Collapsed pixels.
								iterations = -header + 1;
							} else /*if (header === -128)*/ { // Placeholder byte?
								getHeader = true;
							}
						} else {
							var currentByte = this.getBytes(1, stripOffset + byteOffset);

							// Duplicate bytes, if necessary.
							for (var m = 0; m < iterations; m++) {
								if (sampleProperties[sample].hasBytesPerSample) {
									// We're reading one byte at a time, so we need to handle multi-byte samples.
									currentSample = (currentSample << (8 * numBytes)) | currentByte;
									numBytes++;

									// Is our sample complete?
									if (numBytes === sampleProperties[sample].bytesPerSample) {
										pixel.push(currentSample);
										currentSample = numBytes = 0;
										sample++;
									}
								} else {
									throw RangeError("Cannot handle sub-byte bits per sample");
								}

								// Is our pixel complete?
								if (sample === samplesPerPixel)
								{
									strips[i].push(pixel);

									pixel = [];
									sample = 0;
								}
							}

							blockLength--;

							// Is our block complete?
							if (blockLength === 0) {
								getHeader = true;
							}
						}

						jIncrement = 1;
					break;

					// Unknown compression algorithm
					default:
						// Do not attempt to parse the image data.
					break;
				}
			}

//			console.log( strips[i] );
		}

//		console.log( strips );

		if (canvas.getContext) {
			var ctx = this.canvas.getContext("2d");

			// Set a default fill style.
			ctx.fillStyle = this.makeRGBAFillValue(255, 255, 255, 0);

			// If RowsPerStrip is missing, the whole image is in one strip.
			if (fileDirectory.RowsPerStrip) {
				var rowsPerStrip = fileDirectory.RowsPerStrip.values[0];
			} else {
				var rowsPerStrip = imageLength;
			}

			var numStrips = strips.length;

			var imageLengthModRowsPerStrip = imageLength % rowsPerStrip;
			var rowsInLastStrip = (imageLengthModRowsPerStrip === 0) ? rowsPerStrip : imageLengthModRowsPerStrip;

			var numRowsInStrip = rowsPerStrip;
			var numRowsInPreviousStrip = 0;

			var photometricInterpretation = fileDirectory.PhotometricInterpretation.values[0];

			var extraSamplesValues = [];
			var numExtraSamples = 0;

			if (fileDirectory.ExtraSamples) {
				extraSamplesValues = fileDirectory.ExtraSamples.values;
				numExtraSamples = extraSamplesValues.length;
			}

			if (fileDirectory.ColorMap) {
				var colorMapValues = fileDirectory.ColorMap.values;
				var colorMapSampleSize = Math.pow(2, sampleProperties[0].bitsPerSample);
			}

			// Loop through the strips in the image.
			for (var i = 0; i < numStrips; i++) {
				// The last strip may be short.
				if ((i + 1) === numStrips) {
					numRowsInStrip = rowsInLastStrip;
				}

				var numPixels = strips[i].length;
				var yPadding = numRowsInPreviousStrip * i;

				// Loop through the rows in the strip.
				for (var y = 0, j = 0; y < numRowsInStrip, j < numPixels; y++) {
					// Loop through the pixels in the row.
					for (var x = 0; x < imageWidth; x++, j++) {
						var pixelSamples = strips[i][j];

						var red = 0;
						var green = 0;
						var blue = 0;
						var opacity = 1.0;

						if (numExtraSamples > 0) {
							for (var k = 0; k < numExtraSamples; k++) {
								if (extraSamplesValues[k] === 1 || extraSamplesValues[k] === 2) {
									// Clamp opacity to the range [0,1].
									opacity = pixelSamples[3 + k] / 256;

									break;
								}
							}
						}

						switch (photometricInterpretation) {
							// Bilevel or Grayscale
							// WhiteIsZero
							case 0:
								if (sampleProperties[0].hasBytesPerSample) {
									var invertValue = Math.pow(0x10, sampleProperties[0].bytesPerSample * 2);
								}

								// Invert samples.
								pixelSamples.forEach(function(sample, index, samples) { samples[index] = invertValue - sample; });

							// Bilevel or Grayscale
							// BlackIsZero
							case 1:
								red = green = blue = this.clampColorSample(pixelSamples[0], sampleProperties[0].bitsPerSample);
							break;

							// RGB Full Color
							case 2:
								red = this.clampColorSample(pixelSamples[0], sampleProperties[0].bitsPerSample);
								green = this.clampColorSample(pixelSamples[1], sampleProperties[1].bitsPerSample);
								blue = this.clampColorSample(pixelSamples[2], sampleProperties[2].bitsPerSample);
							break;

							// RGB Color Palette
							case 3:
								if (colorMapValues === undefined) {
									throw Error("Palette image missing color map");
								}

								var colorMapIndex = pixelSamples[0];

								red = this.clampColorSample(colorMapValues[colorMapIndex], 16);
								green = this.clampColorSample(colorMapValues[colorMapSampleSize + colorMapIndex], 16);
								blue = this.clampColorSample(colorMapValues[(2 * colorMapSampleSize) + colorMapIndex], 16);
							break;

							// Transparency mask
							case 4:
								throw RangeError( 'Not Yet Implemented: Transparency mask' );
							break;

							// CMYK
							case 5:
								throw RangeError( 'Not Yet Implemented: CMYK' );
							break;

							// YCbCr
							case 6:
								throw RangeError( 'Not Yet Implemented: YCbCr' );
							break;

							// CIELab
							case 8:
								throw RangeError( 'Not Yet Implemented: CIELab' );
							break;

							// Unknown Photometric Interpretation
							default:
								throw RangeError( 'Unknown Photometric Interpretation:', photometricInterpretation );
							break;
						}

						ctx.fillStyle = this.makeRGBAFillValue(red, green, blue, opacity);
						ctx.fillRect(x, yPadding + y, 1, 1);
					}
				}

				numRowsInPreviousStrip = numRowsInStrip;
			}
		}

/*		for (var i = 0, numFileDirectories = this.fileDirectories.length; i < numFileDirectories; i++) {
			// Stuff
		}*/

		return this.canvas;
	},
}
if (typeof module === "undefined") {
    this.TIFFParser = TIFFParser;
} else {
    module.exports = TIFFParser;
}
if (typeof define === "function") {
    define('ThirdParty/tiff-js/tiff',[],function () { return TIFFParser; });
}
;
//define(function () {

/**
*@class
*@memberof Cesium
*/
function Path() { }
/**
*
*获取文件扩展名（后缀）
*@param {String}fname 文件名
*/
Path.GetExtension = function (fname) {
    var start = fname.lastIndexOf(".");
    if (start >= 0) {
        return fname.substring(start, fname.length);
    }
    return "";
}

/**
*
*获取文件扩展名（后缀）
*@param {String}fname 文件名
*/
Path.GetFileName = function (fname) {
    var start = fname.lastIndexOf("/");
    if (start < 0) {
        return fname;
    }
    return fname.substring(start + 1, fname.length);
}
/**
*
*获取文件夹
*@param {String}fname 文件名
*/
Path.GetDirectoryName = function (fname) {
    var start = fname.lastIndexOf("/");
    if (start < 0) {
        return "";
    }
    return fname.substring(0, start);
}
/**
*
*获取文件夹
*@param {String}fname 文件名
*/
Path.Combine = function (dir, fname) {
    return dir + fname;
}
Path.ChangeExtension = function (fname, newExt) {
    return fname.replace(Path.GetExtension(fname), newExt);
}
//    return Path;
//});

if (typeof module === "undefined") {
    this.Path = Path;
} else {
    module.exports = Path;
}
if (typeof define === "function") {
    define('Util/Path',[],function () { return Path; });
}
;
define('Core/Shaders/ShaderLib',[
    'Core/Shaders/ShaderChunk'
], function (
    ShaderChunk
    ) {


    /**
	 * Uniforms library for shared webgl shaders
	 */

    var UniformsLib = {

        common: {

            diffuse: { value: new Cesium.Color(0xeeeeee) },
            opacity: { value: 1.0 },

            map: { value: null },
            offsetRepeat: { value: new Cesium.Cartesian4(0, 0, 1, 1) },

            specularMap: { value: null },
            alphaMap: { value: null },

            envMap: { value: null },
            flipEnvMap: { value: -1 },
            reflectivity: { value: 1.0 },
            refractionRatio: { value: 0.98 }

        },

        aomap: {

            aoMap: { value: null },
            aoMapIntensity: { value: 1 }

        },

        lightmap: {

            lightMap: { value: null },
            lightMapIntensity: { value: 1 }

        },

        emissivemap: {

            emissiveMap: { value: null }

        },

        bumpmap: {

            bumpMap: { value: null },
            bumpScale: { value: 1 }

        },

        normalmap: {

            normalMap: { value: null },
            normalScale: { value: new Cesium.Cartesian2(1, 1) }

        },

        displacementmap: {

            displacementMap: { value: null },
            displacementScale: { value: 1 },
            displacementBias: { value: 0 }

        },

        roughnessmap: {

            roughnessMap: { value: null }

        },

        metalnessmap: {

            metalnessMap: { value: null }

        },

        gradientmap: {

            gradientMap: { value: null }

        },

        fog: {

            fogDensity: { value: 0.00025 },
            fogNear: { value: 1 },
            fogFar: { value: 2000 },
            fogColor: { value: new Cesium.Color(0xffffff) }

        },

        lights: {

            ambientLightColor: { value: [] },

            directionalLights: {
                value: [], properties: {
                    direction: {},
                    color: {},

                    shadow: {},
                    shadowBias: {},
                    shadowRadius: {},
                    shadowMapSize: {}
                }
            },

            directionalShadowMap: { value: [] },
            directionalShadowMatrix: { value: [] },

            spotLights: {
                value: [], properties: {
                    color: {},
                    position: {},
                    direction: {},
                    distance: {},
                    coneCos: {},
                    penumbraCos: {},
                    decay: {},

                    shadow: {},
                    shadowBias: {},
                    shadowRadius: {},
                    shadowMapSize: {}
                }
            },

            spotShadowMap: { value: [] },
            spotShadowMatrix: { value: [] },

            pointLights: {
                value: [], properties: {
                    color: {},
                    position: {},
                    decay: {},
                    distance: {},

                    shadow: {},
                    shadowBias: {},
                    shadowRadius: {},
                    shadowMapSize: {}
                }
            },

            pointShadowMap: { value: [] },
            pointShadowMatrix: { value: [] },

            hemisphereLights: {
                value: [], properties: {
                    direction: {},
                    skyColor: {},
                    groundColor: {}
                }
            },

            // TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src
            rectAreaLights: {
                value: [], properties: {
                    color: {},
                    position: {},
                    width: {},
                    height: {}
                }
            }

        },

        points: {

            diffuse: { value: new Cesium.Color(0xeeeeee) },
            opacity: { value: 1.0 },
            size: { value: 1.0 },
            scale: { value: 1.0 },
            map: { value: null },
            offsetRepeat: { value: new Cesium.Cartesian4(0, 0, 1, 1) }

        }

    };

    /**
	 * Uniform Utilities
	 */

    var 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 && (parameter_src instanceof Cesium.Color ||
						parameter_src instanceof Cesium.Matrix3 || parameter_src instanceof Cesium.Matrix4 ||
						parameter_src instanceof Cesium.Cartesian2 || parameter_src instanceof Cesium.Cartesian3
                        || parameter_src instanceof Cesium.Cartesian4
                        //||parameter_src.isTexture
                        )) {

                        uniforms_dst[u][p] = parameter_src.constructor.clone(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;

        }

    };




    /**
	 * @author alteredq / http://alteredqualia.com/
	 * @author mrdoob / http://mrdoob.com/
	 * @author mikael emtinger / http://gomo.se/
	 */

    var ShaderLib = {

        basic: {

            uniforms: UniformsUtils.merge([
				UniformsLib.common,
				UniformsLib.aomap,
				UniformsLib.lightmap,
				UniformsLib.fog
            ]),

            vertexShader: ShaderChunk.meshbasic_vert,
            fragmentShader: ShaderChunk.meshbasic_frag

        },

        lambert: {

            uniforms: UniformsUtils.merge([
				UniformsLib.common,
				UniformsLib.aomap,
				UniformsLib.lightmap,
				UniformsLib.emissivemap,
				UniformsLib.fog,
				UniformsLib.lights,
				{
				    emissive: { value: new Cesium.Color(0x000000) }
				}
            ]),

            vertexShader: ShaderChunk.meshlambert_vert,
            fragmentShader: ShaderChunk.meshlambert_frag

        },

        phong: {

            uniforms: UniformsUtils.merge([
				UniformsLib.common,
				UniformsLib.aomap,
				UniformsLib.lightmap,
				UniformsLib.emissivemap,
				UniformsLib.bumpmap,
				UniformsLib.normalmap,
				UniformsLib.displacementmap,
				UniformsLib.gradientmap,
				UniformsLib.fog,
				UniformsLib.lights,
				{
				    emissive: { value: new Cesium.Color(0x000000) },
				    specular: { value: new Cesium.Color(0x111111) },
				    shininess: { value: 30 }
				}
            ]),

            vertexShader: ShaderChunk.meshphong_vert,
            fragmentShader: ShaderChunk.meshphong_frag

        },

        standard: {

            uniforms: UniformsUtils.merge([
				UniformsLib.common,
				UniformsLib.aomap,
				UniformsLib.lightmap,
				UniformsLib.emissivemap,
				UniformsLib.bumpmap,
				UniformsLib.normalmap,
				UniformsLib.displacementmap,
				UniformsLib.roughnessmap,
				UniformsLib.metalnessmap,
				UniformsLib.fog,
				UniformsLib.lights,
				{
				    emissive: { value: new Cesium.Color(0x000000) },
				    roughness: { value: 0.5 },
				    metalness: { value: 0.5 },
				    envMapIntensity: { value: 1 } // temporary
				}
            ]),

            vertexShader: ShaderChunk.meshphysical_vert,
            fragmentShader: ShaderChunk.meshphysical_frag

        },

        points: {

            uniforms: UniformsUtils.merge([
				UniformsLib.points,
				UniformsLib.fog
            ]),

            vertexShader: ShaderChunk.points_vert,
            fragmentShader: ShaderChunk.points_frag

        },

        dashed: {

            uniforms: UniformsUtils.merge([
				UniformsLib.common,
				UniformsLib.fog,
				{
				    scale: { value: 1 },
				    dashSize: { value: 1 },
				    totalSize: { value: 2 }
				}
            ]),

            vertexShader: ShaderChunk.linedashed_vert,
            fragmentShader: ShaderChunk.linedashed_frag

        },

        depth: {

            uniforms: UniformsUtils.merge([
				UniformsLib.common,
				UniformsLib.displacementmap
            ]),

            vertexShader: ShaderChunk.depth_vert,
            fragmentShader: ShaderChunk.depth_frag

        },

        normal: {

            uniforms: UniformsUtils.merge([
				UniformsLib.common,
				UniformsLib.bumpmap,
				UniformsLib.normalmap,
				UniformsLib.displacementmap,
				{
				    opacity: { value: 1.0 }
				}
            ]),

            vertexShader: ShaderChunk.normal_vert,
            fragmentShader: ShaderChunk.normal_frag

        },

        /* -------------------------------------------------------------------------
		//	Cube map shader
		 ------------------------------------------------------------------------- */

        cube: {

            uniforms: {
                tCube: { value: null },
                tFlip: { value: -1 },
                opacity: { value: 1.0 }
            },

            vertexShader: ShaderChunk.cube_vert,
            fragmentShader: ShaderChunk.cube_frag

        },

        /* -------------------------------------------------------------------------
		//	Cube map shader
		 ------------------------------------------------------------------------- */

        equirect: {

            uniforms: {
                tEquirect: { value: null },
                tFlip: { value: -1 }
            },

            vertexShader: ShaderChunk.equirect_vert,
            fragmentShader: ShaderChunk.equirect_frag

        },

        distanceRGBA: {

            uniforms: {
                lightPos: { value: new Cesium.Cartesian3() }
            },

            vertexShader: ShaderChunk.distanceRGBA_vert,
            fragmentShader: ShaderChunk.distanceRGBA_frag

        }

    };

    ShaderLib.physical = {

        uniforms: UniformsUtils.merge([
			ShaderLib.standard.uniforms,
			{
			    clearCoat: { value: 0 },
			    clearCoatRoughness: { value: 0 }
			}
        ]),

        vertexShader: ShaderChunk.meshphysical_vert,
        fragmentShader: ShaderChunk.meshphysical_frag

    };

    return ShaderLib;

});
define('Core/MaterialUtils',[
    'Core/Shaders/ShaderChunk',
    'Core/Shaders/ShaderLib',
    'Core/MeshMaterial'
], function (
    ShaderChunk,
    ShaderLib,
    MeshMaterial
    ) {
    var shaderIDs = {
        MeshDepthMaterial: 'depth',
        MeshNormalMaterial: 'normal',
        MeshBasicMaterial: 'basic',
        MeshLambertMaterial: 'lambert',
        MeshPhongMaterial: 'phong',
        MeshToonMaterial: 'phong',
        MeshStandardMaterial: 'physical',
        MeshPhysicalMaterial: 'physical',
        LineBasicMaterial: 'basic',
        LineDashedMaterial: 'dashed',
        PointsMaterial: 'points'
    };

    /**
    *
    *@constructor
    *@memberof Cesium
    */
    function MaterialUtils() {

    }

    /**
   *
   *@param {THREE.Material}material3js
   *@return {Cesium.MeshMaterial}
   */
    MaterialUtils.fromMaterial3js = function (material3js) {
        var shaderID = shaderIDs[material3js.type];
        material3js["is" + material3js.type] = true;
        var shader = THREE.ShaderLib[shaderID];

        if (!shader) {
            shader = material3js;
        }

        var material = new MeshMaterial({
            vertexShader: shader.vertexShader,
            fragmentShader: shader.fragmentShader,
            uniforms: cloneUniforms(shader.uniforms)
        });

        material.material3js = material3js;
        MaterialUtils.updateMaterialFrom3js(material);
        return material;
    }

    function cloneUniforms(uniforms3js) {
        var uniforms = {};
        for (var i in uniforms3js) {
            if (uniforms3js.hasOwnProperty(i)) {
                uniforms[i] = {
                    value: {}
                };
                for (var n in uniforms3js[i]) {
                    if (n!=="value") {
                        uniforms[i][n] = uniforms3js[i][n];
                    }
                }
                if (uniforms3js[i].t) {
                    switch (uniforms3js[i].t) {

                        default:
                    }
                }

                bindUniformValue(uniforms[i], uniforms3js[i].value);
            }
        }
        return uniforms;
    }

    /**
    *
    *@param {Cesium.MeshMaterial}materialWidth3js
    *@private
    */
    MaterialUtils.updateMaterialFrom3js = function (materialWidth3js) {
        if (!materialWidth3js || !materialWidth3js.material3js) {
            return;
        }

        var material3js = materialWidth3js.material3js;
        materialWidth3js.translucent = material3js.transparent;

        materialWidth3js.wireframe = material3js.wireframe;

        var m_uniforms = materialWidth3js.uniforms;
        var material = materialWidth3js.material3js;
        if (material.isMeshBasicMaterial ||
				material.isMeshLambertMaterial ||
				material.isMeshPhongMaterial ||
				material.isMeshStandardMaterial ||
				material.isMeshNormalMaterial ||
				material.isMeshDepthMaterial) {

            refreshUniformsCommon(m_uniforms, material);

        }

        // refresh single material specific uniforms

        if (material.isLineBasicMaterial) {

            refreshUniformsLine(m_uniforms, material);

        } else if (material.isLineDashedMaterial) {

            refreshUniformsLine(m_uniforms, material);
            refreshUniformsDash(m_uniforms, material);

        } else if (material.isPointsMaterial) {

            refreshUniformsPoints(m_uniforms, material);

        } else if (material.isMeshLambertMaterial) {

            refreshUniformsLambert(m_uniforms, material);

        } else if (material.isMeshToonMaterial) {

            refreshUniformsToon(m_uniforms, material);

        } else if (material.isMeshPhongMaterial) {

            refreshUniformsPhong(m_uniforms, material);

        } else if (material.isMeshPhysicalMaterial) {

            refreshUniformsPhysical(m_uniforms, material);

        } else if (material.isMeshStandardMaterial) {

            refreshUniformsStandard(m_uniforms, material);

        } else if (material.isMeshDepthMaterial) {

            if (material.displacementMap) {

                bindUniformValue(m_uniforms.displacementMap, material.displacementMap);
                bindUniformValue(m_uniforms.displacementScale, material.displacementScale);
                bindUniformValue(m_uniforms.displacementBias, material.displacementBias);

            }

        } else if (material.isMeshNormalMaterial) {

            refreshUniformsNormal(m_uniforms, material);

        } else {
            for (var i in material.uniforms) {
                if (material.uniforms.hasOwnProperty(i)) {
                    bindUniformValue(m_uniforms[i], material.uniforms[i].value);
                }
            }
        }
        //if (material.lights) {

        //    // 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.rectAreaLights.value = _lights.rectArea;
        //    //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;
        //    // TODO (abelnation): add area lights shadow info to uniforms

        //} else {
        m_uniforms.ambientLightColor = { value: new Cesium.Color(0.06666666666666667, 0.06666666666666667, 0.06666666666666667) };
        //}
    }



    /**
     *
     *@param {Object}material3js
     *@return {Boolean}
     */
    MaterialUtils.isMaterial3js = function (material3js) {
        return typeof THREE !== 'undefined' && material3js instanceof THREE.Material;
    }
    // Uniforms (refresh bindUniformValue(uniforms objects)

    function refreshUniformsCommon(uniforms, material) {

        bindUniformValue(uniforms.opacity, material.opacity);

        bindUniformValue(uniforms.diffuse, material.color);

        if (material.emissive) {
            var val3js = new material.emissive.constructor().copy(material.emissive).multiplyScalar(material.emissiveIntensity)
            bindUniformValue(uniforms.emissive, val3js);

        }

        bindUniformValue(uniforms.map, material.map);
        bindUniformValue(uniforms.specularMap, material.specularMap);
        bindUniformValue(uniforms.alphaMap, material.alphaMap);

        if (material.lightMap) {

            bindUniformValue(uniforms.lightMap, material.lightMap);
            bindUniformValue(uniforms.lightMapIntensity, material.lightMapIntensity);

        }

        if (material.aoMap) {

            bindUniformValue(uniforms.aoMap, material.aoMap);
            bindUniformValue(uniforms.aoMapIntensity, 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) {

            // backwards compatibility
            if (uvScaleMap.isWebGLRenderTarget) {

                uvScaleMap = uvScaleMap.texture

            }

            var offset = uvScaleMap.offset
            var repeat = uvScaleMap.repeat

            bindUniformValue(uniforms.offsetRepeat, offset);

        }

        bindUniformValue(uniforms.envMap, material.envMap);

        // don't flip CubeTexture envMaps, flip everything else:
        //  WebGLRenderTargetCube will be flipped for backwards compatibility
        //  WebGLRenderTargetCube.texture will be flipped because it's a Texture and NOT a CubeTexture
        // this check must be handled differently, or removed entirely, if WebGLRenderTargetCube uses a CubeTexture in the future
        bindUniformValue(uniforms.flipEnvMap, (!(material.envMap && material.envMap.isCubeTexture)) ? 1 : -1);

        bindUniformValue(uniforms.reflectivity, material.reflectivity);
        bindUniformValue(uniforms.refractionRatio, material.refractionRatio);

    }

    function refreshUniformsLine(uniforms, material) {

        bindUniformValue(uniforms.diffuse, material.color);
        bindUniformValue(uniforms.opacity, material.opacity);

    }

    function refreshUniformsDash(uniforms, material) {

        bindUniformValue(uniforms.dashSize, material.dashSize);
        bindUniformValue(uniforms.totalSize, material.dashSize + material.gapSize);
        bindUniformValue(uniforms.scale, material.scale);

    }

    function refreshUniformsPoints(uniforms, material) {

        bindUniformValue(uniforms.diffuse, material.color);
        bindUniformValue(uniforms.opacity, material.opacity);
        bindUniformValue(uniforms.size, material.size * _pixelRatio);
        bindUniformValue(uniforms.scale, _height * 0.5);

        bindUniformValue(uniforms.map, material.map);

        if (material.map !== null) {

            var offset = material.map.offset;
            var repeat = material.map.repeat;

            bindUniformValue(uniforms.offsetRepeat.value.set(offset.x, offset.y, repeat.x, repeat.y));

        }

    }

    function refreshUniformsFog(uniforms, fog) {

        bindUniformValue(uniforms.fogColor, fog.color);

        if (fog.isFog) {

            bindUniformValue(uniforms.fogNear, fog.near);
            bindUniformValue(uniforms.fogFar, fog.far);

        } else if (fog.isFogExp2) {

            bindUniformValue(uniforms.fogDensity, fog.density);

        }

    }

    function refreshUniformsLambert(uniforms, material) {

        if (material.emissiveMap) {

            bindUniformValue(uniforms.emissiveMap, material.emissiveMap);

        }

    }

    function refreshUniformsPhong(uniforms, material) {

        bindUniformValue(uniforms.specular, material.specular);
        bindUniformValue(uniforms.shininess, Math.max(material.shininess, 1e-4)); // to prevent pow( 0.0, 0.0 )

        if (material.emissiveMap) {

            bindUniformValue(uniforms.emissiveMap, material.emissiveMap);

        }

        if (material.bumpMap) {

            bindUniformValue(uniforms.bumpMap, material.bumpMap);
            bindUniformValue(uniforms.bumpScale, material.bumpScale);

        }

        if (material.normalMap) {

            bindUniformValue(uniforms.normalMap, material.normalMap);
            bindUniformValue(uniforms.normalScale.value.copy(material.normalScale));

        }

        if (material.displacementMap) {

            bindUniformValue(uniforms.displacementMap, material.displacementMap);
            bindUniformValue(uniforms.displacementScale, material.displacementScale);
            bindUniformValue(uniforms.displacementBias, material.displacementBias);

        }

    }

    function refreshUniformsToon(uniforms, material) {

        refreshUniformsPhong(uniforms, material);

        if (material.gradientMap) {

            bindUniformValue(uniforms.gradientMap, material.gradientMap);

        }

    }

    function refreshUniformsStandard(uniforms, material) {

        bindUniformValue(uniforms.roughness, material.roughness);
        bindUniformValue(uniforms.metalness, material.metalness);

        if (material.roughnessMap) {

            bindUniformValue(uniforms.roughnessMap, material.roughnessMap);

        }

        if (material.metalnessMap) {

            bindUniformValue(uniforms.metalnessMap, material.metalnessMap);

        }

        if (material.emissiveMap) {

            bindUniformValue(uniforms.emissiveMap, material.emissiveMap);

        }

        if (material.bumpMap) {

            bindUniformValue(uniforms.bumpMap, material.bumpMap);
            bindUniformValue(uniforms.bumpScale, material.bumpScale);

        }

        if (material.normalMap) {

            bindUniformValue(uniforms.normalMap, material.normalMap);
            bindUniformValue(uniforms.normalScale.value.copy(material.normalScale));

        }

        if (material.displacementMap) {

            bindUniformValue(uniforms.displacementMap, material.displacementMap);
            bindUniformValue(uniforms.displacementScale, material.displacementScale);
            bindUniformValue(uniforms.displacementBias, material.displacementBias);

        }

        if (material.envMap) {

            //bindUniformValue(uniforms.envMap, material.envMap); // part of bindUniformValue(uniforms common
            bindUniformValue(uniforms.envMapIntensity, material.envMapIntensity);

        }

    }

    function refreshUniformsPhysical(uniforms, material) {

        bindUniformValue(uniforms.clearCoat, material.clearCoat);
        bindUniformValue(uniforms.clearCoatRoughness, material.clearCoatRoughness);

        refreshUniformsStandard(uniforms, material)

    }

    function refreshUniformsNormal(uniforms, material) {

        if (material.bumpMap) {

            bindUniformValue(uniforms.bumpMap, material.bumpMap);
            bindUniformValue(uniforms.bumpScale, material.bumpScale);

        }

        if (material.normalMap) {

            bindUniformValue(uniforms.normalMap, material.normalMap);
            bindUniformValue(uniforms.normalScale.value.copy(material.normalScale));

        }

        if (material.displacementMap) {

            bindUniformValue(uniforms.displacementMap, material.displacementMap);
            bindUniformValue(uniforms.displacementScale, material.displacementScale);
            bindUniformValue(uniforms.displacementBias, material.displacementBias);

        }

    }

    function bindUniformValue(valCesium, val3js) {

        var type = typeof val3js;
        if (type === 'undefined') {
            valCesium.value = undefined;
            return;
        }
        if (val3js === null) {
            valCesium.value = null; return;
        }
        if (typeof valCesium.value !== "undefined"
            && valCesium.value != null
            && (valCesium.value.constructor
            && valCesium.value.constructor.clone
            && val3js.constructor == valCesium.value.constructor)) {

            valCesium.value = valCesium.value.constructor.clone(val3js);
        } else {
            switch (type) {
                case "number":
                case "string":
                    valCesium.value = val3js;
                    break;
                case "object":
                    if (val3js instanceof THREE.Vector2) {
                        if (!valCesium.value.constructor.clone) {
                            valCesium.value = new Cesium.Cartesian2();
                        }
                    }
                    if (val3js instanceof THREE.Vector3) {
                        if (!valCesium.value.constructor.clone) {
                            valCesium.value = new Cesium.Cartesian3();
                        }
                    }
                    if (val3js instanceof THREE.Vector4) {
                        if (!valCesium.value.constructor.clone) {
                            valCesium.value = new Cesium.Cartesian4();
                        }
                    }
                    if (val3js instanceof THREE.Matrix3) {
                        if (!valCesium.value.constructor.clone) {
                            valCesium.value = new Cesium.Matrix3();
                        }
                    }
                    if (val3js instanceof THREE.Matrix4) {
                        if (!valCesium.value.constructor.clone) {
                            valCesium.value = new Cesium.Matrix4();
                        }
                    }
                    if (val3js instanceof THREE.Color) {
                        if (!valCesium.value.constructor.clone) {
                            valCesium.value = new Cesium.Color(val3js.r, val3js.g, val3js.b, val3js.a);
                        }
                    } else if (valCesium.value != null && valCesium.value.constructor.clone) {
                        valCesium.value.constructor.clone(val3js, valCesium.value);
                    } else if (val3js instanceof THREE.Texture) {
                        if (valCesium.value != val3js.image) {
                            valCesium.value = val3js.image;
                            var sampler = {};

                            sampler.magnificationFilter = Cesium.WebGLConstants.LINEAR;
                            sampler.minificationFilter = Cesium.WebGLConstants.NEAREST_MIPMAP_LINEAR;
                            sampler.wrapS = Cesium.WebGLConstants.REPEAT;
                            sampler.wrapT = Cesium.WebGLConstants.REPEAT;
                            valCesium.sampler = sampler;
                            valCesium.flipY = val3js.flipY;

                            valCesium.needsUpdate = true;
                        }
                    } else {
                        valCesium.value = val3js;
                    }
                    break;
                default:
                    console.log("未知uniform.value类型");
                    break;
            }
        }
    }

    return MaterialUtils;
});
define('Core/MeshUtils',[
    'Core/MaterialUtils',
    'Core/GeometryUtils',
    'Core/Mesh'
], function (
    MaterialUtils,
    GeometryUtils,
    Mesh
    ) {

    /**
    *
    *@constructor
    *@memberof Cesium
    */
    function MeshUtils() {

    }

    /**
    *
    *@param {THREE.Mesh}mesh3js
    *@return {Cesium.Mesh}
    */
    MeshUtils.fromMesh3js = function (mesh3js) {
        if (!MeshUtils.isMesh3js(mesh3js)) {
            return undefined;
        }
        var geometry = mesh3js.geometry;
        if (GeometryUtils.isGeometry3js(geometry)) {
            geometry = GeometryUtils.fromGeometry3js(geometry);
            //if (mesh3js.material.type === "MeshNormalMaterial" || mesh3js.material.type === "MeshPhongMaterial") {
            //    GeometryUtils.computeVertexNormals(geometry)
            //}
        }
        var material = mesh3js.material;
        if (MaterialUtils.isMaterial3js(material)) {
            material = MaterialUtils.fromMaterial3js(material);
        }
        var mesh = new Mesh({
            geometry: geometry,
            material: material,
            position: mesh3js.position,
            scale: mesh3js.scale
        });
        mesh.quaternion = mesh3js.quaternion;
        return mesh;
    }
    /**
     *
     *@param {Object}mesh
     *@return {Boolean}
     */
    MeshUtils.isMesh3js = function (mesh) {
        return typeof THREE !== 'undefined' && mesh instanceof THREE.Mesh;
    }
    return MeshUtils;
});
define('Core/ShaderUtils',[ ], function (

    ) {
    /**
   *
   *@memberof Cesium
   *@constructor
   */
    function ShaderUtils() {

    }

    /**
    *
    *
    */
    ShaderUtils.processShader3js = function (material3js, shader) {
        var program = new WebGLProgram(material3js, shader);
        return program;

    }

    if (typeof THREE=='undefined') {

        return ShaderUtils;
    }
    var shaderIDs = {
        MeshDepthMaterial: 'depth',
        MeshNormalMaterial: 'normal',
        MeshBasicMaterial: 'basic',
        MeshLambertMaterial: 'lambert',
        MeshPhongMaterial: 'phong',
        MeshToonMaterial: 'phong',
        MeshStandardMaterial: 'physical',
        MeshPhysicalMaterial: 'physical',
        LineBasicMaterial: 'basic',
        LineDashedMaterial: 'dashed',
        PointsMaterial: 'points'
    };

    var parameterNames = [
		"precision", "supportsVertexTextures", "map", "mapEncoding", "envMap", "envMapMode", "envMapEncoding",
		"lightMap", "aoMap", "emissiveMap", "emissiveMapEncoding", "bumpMap", "normalMap", "displacementMap", "specularMap",
		"roughnessMap", "metalnessMap", "gradientMap",
		"alphaMap", "combine", "vertexColors", "fog", "useFog", "fogExp",
		"flatShading", "sizeAttenuation", "logarithmicDepthBuffer", "skinning",
		"maxBones", "useVertexTexture", "morphTargets", "morphNormals",
		"maxMorphTargets", "maxMorphNormals", "premultipliedAlpha",
		"numDirLights", "numPointLights", "numSpotLights", "numHemiLights", "numRectAreaLights",
		"shadowMapEnabled", "shadowMapType", "toneMapping", 'physicallyCorrectLights',
		"alphaTest", "doubleSided", "flipSided", "numClippingPlanes", "numClipIntersection", "depthPacking"
    ];
    var ShaderChunk = THREE.ShaderChunk;
    var ShaderLib = THREE.ShaderLib;
    var BackSide = THREE.BackSide,
        DoubleSide = THREE.DoubleSide,
        FlatShading = THREE.FlatShading,
        CubeUVRefractionMapping = THREE.CubeUVRefractionMapping,
        CubeUVReflectionMapping = THREE.CubeUVReflectionMapping,
        GammaEncoding = THREE.GammaEncoding,
        LinearEncoding = THREE.LinearEncoding,
    NoToneMapping = THREE.NoToneMapping,
    AddOperation = THREE.AddOperation,
    MixOperation = THREE.MixOperation,
    MultiplyOperation = THREE.MultiplyOperation,
    EquirectangularRefractionMapping = THREE.EquirectangularRefractionMapping,
    CubeRefractionMapping = THREE.CubeRefractionMapping,
    SphericalReflectionMapping = THREE.SphericalReflectionMapping,
    EquirectangularReflectionMapping = THREE.EquirectangularReflectionMapping,
    CubeReflectionMapping = THREE.CubeReflectionMapping,
    PCFSoftShadowMap = THREE.PCFSoftShadowMap,
    PCFShadowMap = THREE.PCFShadowMap,
    CineonToneMapping = THREE.CineonToneMapping,
    Uncharted2ToneMapping = THREE.Uncharted2ToneMapping,
    ReinhardToneMapping = THREE.ReinhardToneMapping,
    LinearToneMapping = THREE.LinearToneMapping,
    GammaEncoding = THREE.GammaEncoding,
    RGBDEncoding = THREE.RGBDEncoding,
    RGBM16Encoding = THREE.RGBM16Encoding,
    RGBM7Encoding = THREE.RGBM7Encoding,
    RGBEEncoding = THREE.RGBEEncoding,
    sRGBEncoding = THREE.sRGBEncoding;





    function getTextureEncodingFromMap(map, gammaOverrideLinear) {

        var encoding;

        if (!map) {

            encoding = LinearEncoding;

        } else if (map.isTexture) {

            encoding = map.encoding;

        } else if (map.isWebGLRenderTarget) {

            console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead.");
            encoding = map.texture.encoding;

        }

        // add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point.
        if (encoding === LinearEncoding && gammaOverrideLinear) {

            encoding = GammaEncoding;

        }

        return encoding;

    }

    function getParameters(material) {//, lights, fog, nClipPlanes, nClipIntersection, 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 currentRenderTarget = null;// renderer.getCurrentRenderTarget();
        var renderer = {};
        var parameters = {

            shaderID: shaderID,

            precision: "high",//precision,
            supportsVertexTextures: true,// capabilities.vertexTextures,
            outputEncoding: getTextureEncodingFromMap((!currentRenderTarget) ? null : currentRenderTarget.texture, renderer.gammaOutput),
            map: !!material.map,
            mapEncoding: getTextureEncodingFromMap(material.map, renderer.gammaInput),
            envMap: !!material.envMap,
            envMapMode: material.envMap && material.envMap.mapping,
            envMapEncoding: getTextureEncodingFromMap(material.envMap, renderer.gammaInput),
            envMapCubeUV: (!!material.envMap) && ((material.envMap.mapping === CubeUVReflectionMapping) || (material.envMap.mapping === CubeUVRefractionMapping)),
            lightMap: !!material.lightMap,
            aoMap: !!material.aoMap,
            emissiveMap: !!material.emissiveMap,
            emissiveMapEncoding: getTextureEncodingFromMap(material.emissiveMap, renderer.gammaInput),
            bumpMap: !!material.bumpMap,
            normalMap: !!material.normalMap,
            displacementMap: !!material.displacementMap,
            roughnessMap: !!material.roughnessMap,
            metalnessMap: !!material.metalnessMap,
            specularMap: !!material.specularMap,
            alphaMap: !!material.alphaMap,

            gradientMap: !!material.gradientMap,

            combine: material.combine,

            vertexColors: material.vertexColors,

            fog: false,//!!fog,
            useFog: material.fog,
            fogExp: false,//(fog && fog.isFogExp2),

            flatShading: material.shading === FlatShading,

            sizeAttenuation: material.sizeAttenuation,
            logarithmicDepthBuffer: false,// 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: 0,// lights.directional.length,
            numPointLights: 0,// lights.point.length,
            numSpotLights: 0,// lights.spot.length,
            numRectAreaLights: 0,// lights.rectArea.length,
            numHemiLights: 0,// lights.hemi.length,

            numClippingPlanes: 0,//nClipPlanes,
            numClipIntersection: 0,//nClipIntersection,

            //shadowMapEnabled:  renderer.shadowMap.enabled && object.receiveShadow && lights.shadows.length > 0,
            //shadowMapType: renderer.shadowMap.type,

            //toneMapping: renderer.toneMapping,
            //physicallyCorrectLights: renderer.physicallyCorrectLights,

            premultipliedAlpha: material.premultipliedAlpha,

            alphaTest: material.alphaTest,
            doubleSided: material.side === DoubleSide,
            flipSided: material.side === BackSide,

            depthPacking: (material.depthPacking !== undefined) ? material.depthPacking : false

        };

        return parameters;

    };

    /**
	 * @author mrdoob / http://mrdoob.com/
	 */

    var programIdCount = 0;

    function getEncodingComponents(encoding) {

        switch (encoding) {

            case LinearEncoding:
                return ['Linear', '( value )'];
            case sRGBEncoding:
                return ['sRGB', '( value )'];
            case RGBEEncoding:
                return ['RGBE', '( value )'];
            case RGBM7Encoding:
                return ['RGBM', '( value, 7.0 )'];
            case RGBM16Encoding:
                return ['RGBM', '( value, 16.0 )'];
            case RGBDEncoding:
                return ['RGBD', '( value, 256.0 )'];
            case GammaEncoding:
                return ['Gamma', '( value, float( GAMMA_FACTOR ) )'];
            default:
                throw new Error('unsupported encoding: ' + encoding);

        }

    }

    function getTexelDecodingFunction(functionName, encoding) {

        var components = getEncodingComponents(encoding);
        return "vec4 " + functionName + "( vec4 value ) {  return " + components[0] + "ToLinear" + components[1] + " ; }";

    }

    function getTexelEncodingFunction(functionName, encoding) {

        var components = getEncodingComponents(encoding);
        return "vec4 " + functionName + "( vec4 value ) { return LinearTo" + components[0] + components[1] + " ; }";

    }

    function getToneMappingFunction(functionName, toneMapping) {

        var toneMappingName;

        switch (toneMapping) {

            case LinearToneMapping:
                toneMappingName = "Linear";
                break;

            case ReinhardToneMapping:
                toneMappingName = "Reinhard";
                break;

            case Uncharted2ToneMapping:
                toneMappingName = "Uncharted2";
                break;

            case CineonToneMapping:
                toneMappingName = "OptimizedCineon";
                break;

            default:
                throw new Error('unsupported toneMapping: ' + toneMapping);

        }

        return "vec3 " + functionName + "( vec3 color ) {  return " + toneMappingName + "ToneMapping( color );  }";

    }

    function generateExtensions(extensions, parameters, rendererExtensions) {

        extensions = extensions || {};

        var chunks = [
			(extensions.derivatives || parameters.envMapCubeUV || 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 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_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights)
			.replace(/NUM_POINT_LIGHTS/g, parameters.numPointLights)
			.replace(/NUM_HEMI_LIGHTS/g, parameters.numHemiLights);

    }

    function parseIncludes(string) {

        var pattern = /^[ \t]*#include +<([\w\d.]+)>/gm;

        function replace(match, include) {

            var replace = ShaderChunk[include];

            if (replace === undefined) {

                throw new Error('Can not resolve #include <' + include + '>');

            }

            return parseIncludes(replace);

        }

        return string.replace(pattern, replace);

    }

    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);

    }

    function WebGLProgram(material, shader) {//, parameters) {

        var parameters = getParameters(material);
        //var shader = ShaderLib[parameters.shaderID];

        //var extensions = material.extensions;
        var defines = material.defines;

        var vertexShader = shader.vertexShader;
        var fragmentShader = shader.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 CubeReflectionMapping:
                case CubeRefractionMapping:
                    envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
                    break;

                case CubeUVReflectionMapping:
                case CubeUVRefractionMapping:
                    envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';
                    break;

                case EquirectangularReflectionMapping:
                case EquirectangularRefractionMapping:
                    envMapTypeDefine = 'ENVMAP_TYPE_EQUIREC';
                    break;

                case SphericalReflectionMapping:
                    envMapTypeDefine = 'ENVMAP_TYPE_SPHERE';
                    break;

            }

            switch (material.envMap.mapping) {

                case CubeRefractionMapping:
                case EquirectangularRefractionMapping:
                    envMapModeDefine = 'ENVMAP_MODE_REFRACTION';
                    break;

            }

            switch (material.combine) {

                case MultiplyOperation:
                    envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
                    break;

                case MixOperation:
                    envMapBlendingDefine = 'ENVMAP_BLENDING_MIX';
                    break;

                case AddOperation:
                    envMapBlendingDefine = 'ENVMAP_BLENDING_ADD';
                    break;

            }

        }

        var gammaFactorDefine = 1.0;// (renderer.gammaFactor > 0) ? renderer.gammaFactor : 1.0;


        // var customExtensions = generateExtensions(extensions, parameters, renderer.extensions);

        var customDefines = generateDefines(defines);


        var prefixVertex, prefixFragment;

        if (material.isRawShaderMaterial) {

            prefixVertex = [

				customDefines,

				'\n'

            ].filter(filterEmptyLine).join('\n');

            prefixFragment = [

				//customExtensions,
				customDefines,

				'\n'

            ].filter(filterEmptyLine).join('\n');

        } else {

            prefixVertex = [

				//'precision ' + parameters.precision + ' float;',
				//'precision ' + parameters.precision + ' int;',

				'#define SHADER_NAME ' + shader.name,

				//customDefines,

				parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',

				'#define GAMMA_FACTOR ' + gammaFactorDefine,

				'#define MAX_BONES ' + parameters.maxBones,
				//(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 ' + 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' : '',

				'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,

				parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
				parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',

				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 ' + shader.name,

				customDefines,

				parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '',

				'#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.gradientMap ? '#define USE_GRADIENTMAP' : '',

				parameters.flatShading ? '#define FLAT_SHADED' : '',

				parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
				parameters.flipSided ? '#define FLIP_SIDED' : '',

				'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,
				'#define UNION_CLIPPING_PLANES ' + (parameters.numClippingPlanes - parameters.numClipIntersection),

				parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
				parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',

				parameters.premultipliedAlpha ? "#define PREMULTIPLIED_ALPHA" : '',

				parameters.physicallyCorrectLights ? "#define PHYSICALLY_CORRECT_LIGHTS" : '',

				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;',

				//(parameters.toneMapping !== THREE.NoToneMapping) ? "#define TONE_MAPPING" : '',
				//(parameters.toneMapping !== THREE.NoToneMapping) ? ShaderChunk['tonemapping_pars_fragment'] : '',  // this code is required here because it is used by the toneMapping() function defined below
				//(parameters.toneMapping !== THREE.NoToneMapping) ? getToneMappingFunction("toneMapping", parameters.toneMapping) : '',

				parameters.dithering ? '#define DITHERING' : '',

				(parameters.outputEncoding || parameters.mapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding) ? ShaderChunk['encodings_pars_fragment'] : '', // this code is required here because it is used by the various encoding/decoding function defined below
				parameters.mapEncoding ? getTexelDecodingFunction('mapTexelToLinear', parameters.mapEncoding) : '',
				parameters.envMapEncoding ? getTexelDecodingFunction('envMapTexelToLinear', parameters.envMapEncoding) : '',
				parameters.emissiveMapEncoding ? getTexelDecodingFunction('emissiveMapTexelToLinear', parameters.emissiveMapEncoding) : '',
				parameters.outputEncoding ? getTexelEncodingFunction("linearToOutputTexel", parameters.outputEncoding) : '',

				parameters.depthPacking ? "#define DEPTH_PACKING " + material.depthPacking : '',

				'\n'

            ].filter(filterEmptyLine).join('\n');

        }

        vertexShader = parseIncludes(vertexShader);
        vertexShader = replaceLightNums(vertexShader, parameters);

        fragmentShader = parseIncludes(fragmentShader);
        fragmentShader = replaceLightNums(fragmentShader, parameters);

        if (!material.isShaderMaterial) {

            vertexShader = unrollLoops(vertexShader);
            fragmentShader = unrollLoops(fragmentShader);

        }

        var vertexGlsl = prefixVertex + vertexShader;
        var fragmentGlsl = prefixFragment + fragmentShader;


        this.id = programIdCount++;
        this.usedTimes = 1;
        this.vertexShader = vertexGlsl;
        this.fragmentShader = fragmentGlsl;

        return this;

    }


    return ShaderUtils;
});
define('Core/MeshVisualizer',[
    'Core/Mesh',
    'Core/RendererUtils',
    'Core/MeshMaterial',
    'Core/Shaders/ShaderChunk',
    'Core/Rotation',
    'Core/FramebufferTexture',
    'Core/LOD',
    'Core/ReferenceMesh',
    'ThirdParty/tiff-js/tiff',
    'Util/Path',
    'Core/GeometryUtils',
    'Core/MaterialUtils',
    'Core/MeshUtils',
    'Core/ShaderUtils'
], function (
    Mesh,
    RendererUtils,
    MeshMaterial,
    ShaderChunk,
    Rotation,
    FramebufferTexture,
    LOD,
    ReferenceMesh,
    TIFFParser,
    Path,
    GeometryUtils,
    MaterialUtils,
    MeshUtils,
    ShaderUtils
) {

    var Matrix4 = Cesium.Matrix4;
    var DrawCommand = Cesium.DrawCommand;
    var defined = Cesium.defined;
    var GeometryPipeline = Cesium.GeometryPipeline;
    var BufferUsage = Cesium.BufferUsage;
    var BlendingState = Cesium.BlendingState;
    var VertexArray = Cesium.VertexArray;
    var ShaderProgram = Cesium.ShaderProgram;
    var DepthFunction = Cesium.DepthFunction;
    var CullFace = Cesium.CullFace;
    var RenderState = Cesium.RenderState;
    var defaultValue = Cesium.defaultValue;
    var Texture = Cesium.Texture;
    var PixelFormat = Cesium.PixelFormat;
    var BoxGeometry = Cesium.BoxGeometry;
    var Cartesian3 = Cesium.Cartesian3;
    var VertexFormat = Cesium.VertexFormat;
    var CubeMap = Cesium.CubeMap;
    var loadCubeMap = Cesium.loadCubeMap;
    var Matrix3 = Cesium.Matrix3;
    var CesiumMath = Cesium.Math;
    var Color = Cesium.Color;

    var scratchTranslation = new Cartesian3();
    var scratchQuaternion = new Cesium.Quaternion();
    var scratchScale = new Cartesian3();
    var scratchTranslationQuaternionRotationScale = new Matrix4();
    var computeModelMatrix = new Matrix4();
    var scratchPosition = new Cartesian3();
    var scratchTraverseArgs = {
        cancelCurrent: false //停止遍历当前节点的所有子节点
    };
    Cesium.Cartesian3.prototype.set = function (x, y, z) {
        this.x = x; this.y = y; this.z = z;
    }
    Cesium.Cartesian3.prototype.copy = function (src) {
        this.x = src.x; this.y = src.y; this.z = src.z;
    }

    Cesium.Cartesian2.prototype.set = function (x, y) {
        this.x = x; this.y = y;
    }
    Cesium.Cartesian2.prototype.copy = function (src) {
        this.x = src.x; this.y = src.y;
    }
    Cesium.Quaternion.prototype.set = function (x, y, z, w) {
        this.x = x; this.y = y; this.z = z; this.w = w;
    }
    Cesium.Quaternion.prototype.copy = function (src) {
        this.x = src.x; this.y = src.y; this.z = src.z; this.w = src.w;
    }
    /**
    *
    *
    *@param {Object}options
    *@param {Cesium.Matrix4}[options.modelMatrix=Cesium.Matrix4.IDENTITY]
    *@param {Cesium.Cartesian3}[options.up=Cesium.Cartesian3.UNIT_Z]
    *@param {Cesium.Cartesian3}[options.position=Cesium.Cartesian3.ZERO]
    *@param {Cesium.Cartesian3}[options.scale=new Cartesian3(1, 1, 1)]
    *@param {Cesium.Rotation}[options.rotation]
    *@param {Boolean}[options.show=true]
    *@param {Boolean}[options.showReference=true]
    *@param {Cesium.ArrowGeometry}[options.referenceAxisParameter]
    *
    *@property {Cesium.Matrix4}modelMatrix
    *@property {Cesium.Cartesian3}up
    *@property {Cesium.Cartesian3}position
    *@property {Cesium.Cartesian3}scale
    *@property {Cesium.Rotation}rotation
    *@property {Boolean}show
    *@property {Boolean}showReference
    *@property {Boolean}modelMatrixNeedsUpdate
    *@property {Cesium.Event}beforeUpdate
    *
    *@constructor
    *@memberof Cesium
    *@extends Cesium.Primitive
    *
    *@example

        MeshVisualizer = Cesium.MeshVisualizer;
        Mesh = Cesium.Mesh;
        MeshMaterial = Cesium.MeshMaterial;
        FramebufferTexture = Cesium.FramebufferTexture;

        var center = Cesium.Cartesian3.fromDegrees(homePosition[0], homePosition[1], 50000);
        var modelMatrix = Cesium.Transforms.eastNorthUpToFixedFrame(center);

        var meshVisualizer = new MeshVisualizer({
            modelMatrix: modelMatrix,
        });
        viewer.scene.primitives.add(meshVisualizer);


        //示例1：Cesium.Geometry+Cesium.MeshMaterial组合
        var box = Cesium.BoxGeometry.createGeometry(Cesium.BoxGeometry.fromDimensions({
            dimensions: new Cesium.Cartesian3(100000, 50000, 50000),
            vertexFormat: Cesium.VertexFormat.POSITION_ONLY
        }));

        var material = new MeshMaterial({
            defaultColor: "rgba(255,0,0,1.0)",
            wireframe: false,
            side: MeshMaterial.Sides.DOUBLE
        });
        var boxMesh = new Mesh(box, material);

        meshVisualizer.add(boxMesh);

        //示例2：Cesium.CSG+Cesium.MeshMaterial组合，可以用Cesium.CSG做布尔运算并渲染运算结果

        //首先使用Cesium创建球体
         var sphere = new Cesium.SphereGeometry({
             radius: 50000.0,
             vertexFormat: Cesium.VertexFormat.POSITION_ONLY
         });
         sphere = Cesium.SphereGeometry.createGeometry(sphere);

         var sphereMesh = new Mesh(sphere, material);
         sphereMesh.position = new Cesium.Cartesian3(100000, 0, 0)
         meshVisualizer.add(sphereMesh);

         //将球体对象Cesium.SphereGeometry转成Cesium.CSG实例
         sphere = CSG.toCSG(sphere);
         //将盒子对象转成Cesium.CSG实例
         box = CSG.toCSG(box);

          //做布尔运算
          var subResult = sphere.subtract(box);
          //渲染运算结果
          var subResultMesh = new Mesh(subResult, material);
          subResultMesh.position = new Cesium.Cartesian3(700000, 0, 0)
          meshVisualizer.add(subResultMesh);

          //示例3：使用帧缓存作纹理,实际应用中如体绘制，风场流场绘制等等都可以运用此技术

          function createGeometry() {
            var p1 = new Cesium.Cartesian3(-50000, 50000, 100);
            var p2 = new Cesium.Cartesian3(-50000, -50000, 100);
            var p3 = new Cesium.Cartesian3(50000, -50000, 100);
            var p4 = new Cesium.Cartesian3(50000, 50000, 100);

            var positions = new Float64Array([
              p1.x, p1.y, p1.z,
              p2.x, p2.y, p2.z,
              p3.x, p3.y, p3.z,
              p4.x, p4.y, p4.z
            ]);
            var indices = new Uint16Array([
              0, 1, 3,
              1, 2, 3,
            ]);
            var sts = new Float32Array([
              1, 1,
              1, 0,
              0, 0,
              0, 1
            ]);
            var geometry = new Cesium.Geometry({
                attributes: {
                    position: new Cesium.GeometryAttribute({
                        componentDatatype: Cesium.ComponentDatatype.DOUBLE,
                        componentsPerAttribute: 3,
                        values: positions
                    }),
                    st: new Cesium.GeometryAttribute({
                        componentDatatype: Cesium.ComponentDatatype.FLOAT,
                        componentsPerAttribute: 2,
                        values: sts
                    })
                },
                indices: indices,
                primitiveType: Cesium.PrimitiveType.TRIANGLES,
                boundingSphere: Cesium.BoundingSphere.fromVertices(positions)
            });

            return geometry;
        }
        //将上文中的盒子渲染到缓存，作为纹理参与createGeometry（）方法创建的几何体渲染过程
        var framebufferTex = new FramebufferTexture(boxMesh);
        var geometry = createGeometry();
        var customMesh = new Mesh(geometry, new MeshMaterial({

            uniforms: {
                u_textureMap: framebufferTex//Cesium.buildModuleUrl('Widgets/Images/TerrainProviders/STK.png')
            },
            side: MeshMaterial.Sides.DOUBLE,
            vertexShader : "\n\
                \n\
                varying vec3 v_position;\n\
                varying vec2 v_st;\n\
                \n\
                void main(void) \n\
                {\n\
                vec4 pos = u_modelViewMatrix * vec4(position,1.0);\n\
                v_position = pos.xyz;\n\
                v_st=st;\n\
                gl_Position = u_projectionMatrix * pos;\n\
                }",
            fragmentShader : "varying vec2 v_st;\
                uniform sampler2D u_textureMap;\
                void main()\
                {\
                gl_FragColor = texture2D(u_textureMap,v_st);\n\
                \
                }\
                "
        }));
        customMesh.position = new Cesium.Cartesian3(100000, 0, 0);
        meshVisualizer.add(customMesh);
    */
    function MeshVisualizer(options) {
        this._modelMatrix = defaultValue(options.modelMatrix, Matrix4.IDENTITY);
        this._actualModelMatrix = Matrix4.clone(this._modelMatrix);
        this._ready = true;
        this._modelMatrixNeedsUpdate = true;

        this._isWireframe = false;
        this._up = defaultValue(options.up, new Cartesian3(0, 0, 1));
        this._position = defaultValue(options.position, new Cartesian3(0, 0, 0));
        this._scale = defaultValue(options.scale, new Cartesian3(1, 1, 1));
        this._rotation = defaultValue(options.rotation, { axis: new Cartesian3(0, 0, 1), angle: 0 });
        this._rotation = new Rotation(this._rotation.axis, this._rotation.angle);
        this._rotation.paramChanged.addEventListener(this.onModelMatrixNeedUpdate, this);


        this._chidren = [];
        this._debug = false;
        this._show = defaultValue(options.show, true);

        this._center = new Cartesian3();
        Cesium.Matrix4.getTranslation(this._modelMatrix, this._center);
        this._framebufferTextures = {};
        this._uniformValueCache = {};
        this._textureCache = {};
        this._uniformMaps = {};
        this.referenceMesh = new ReferenceMesh({
            axisParameter: defaultValue(options.referenceAxisParameter, { length: 50000 * 2 }),
            show: defaultValue(options.showReference, false)
        });
        this.add(this.referenceMesh);
        this._pickIds = [];
        this.beforeUpdate = new Cesium.Event();
        this._scene = options.scene;
    }
    var world2localMatrix = new Cesium.Matrix4();
    var surfacePointLocal = new Cesium.Cartesian3();
    var rayDir = new Cesium.Cartesian3();
    var pos = new Cesium.Cartesian3();
    var rayOriginLocal = new Cesium.Cartesian3();
    var scratchRay = new Cesium.Ray();

    MeshVisualizer.prototype = {
        /**
        *@param {Cesium.Mesh}mesh
        */
        remove: function (mesh) {

            for (var i = 0; i < this._chidren.length; i++) {
                if (this._chidren[i] == mesh) {

                    this._chidren.splice(i, 1);
                }
            }
            MeshVisualizer.traverse(mesh, function () {
                if (mesh._drawCommand) {
                    mesh._drawCommand.destroy && mesh._drawCommand.destroy();
                }
                if (mesh._actualMesh && mesh._actualMesh._drawCommand) {
                    Cesium.destroyObject(mesh._actualMesh._drawCommand);
                    Cesium.destroyObject(mesh._actualMesh.geometry);
                    Cesium.destroyObject(mesh._actualMesh);
                    Cesium.destroyObject(mesh);
                }
            }, false);
        },
        /**
        *
        *拾取点，用局部坐标系表达。内部使用Cesium.Scene.pickPosition和MeshVisualizer.worldCoordinatesToLocal实现。
        *@param {Cesium.Cartesian2}windowPosition
        *@param {Cesium.Ray}result
        *@return {Cesium.Cartesian3}
        */
        pickPosition: function (windowPosition, result) {
            if (!this._scene) {
                return undefined;
            }
            this._scene.pickPosition(windowPosition, surfacePointLocal);

            if (!surfacePointLocal) {
                return undefined;
            }

            this.worldCoordinatesToLocal(surfacePointLocal, surfacePointLocal);
            Cesium.Cartesian3.clone(surfacePointLocal, result);
            return result;
        },
        /**
        *
        *创建一条射线，用局部坐标系表达
        *@param {Cesium.Cartesian2}windowPosition
        *@param {Cesium.Ray}result
        *@return {Cesium.Ray}
        */
        getPickRay: function (windowPosition, result) {
            if (!this._scene) {
                return undefined;
            }
            if (!result) {
                result = Cesium.Ray();
            }
            this._scene.camera.getPickRay(windowPosition, scratchRay);//ray用于计算小球发射点位置，这里射线的起始点是世界坐标，不能像Threejs那样直接拿来计算，需要转成局部坐标
            this._scene.pickPosition(windowPosition, surfacePointLocal);//射线和局部场景的交点

            if (!surfacePointLocal) {
                return undefined;
            }

            Cesium.Cartesian3.clone(scratchRay.direction, rayDir);

            //世界坐标转局部坐标
            this.worldCoordinatesToLocal(scratchRay.origin, rayOriginLocal);
            this.worldCoordinatesToLocal(surfacePointLocal, surfacePointLocal);

            Cesium.Cartesian3.add(rayOriginLocal, rayDir, pos);
            //计算发射方向
            Cesium.Cartesian3.subtract(surfacePointLocal, pos, rayDir);
            Cesium.Cartesian3.clone(surfacePointLocal, result.origin);
            Cesium.Cartesian3.clone(rayDir, result.direction);
            return result;
        },
        /**
        *世界坐标到局部坐标
        *@param {Cesium.Cartesian3}worldCoordinates
        *@param {Cesium.Cartesian3}result
        *@return {Cesium.Cartesian3}
        */
        worldCoordinatesToLocal: function (worldCoordinates, result) {
            if (!result) {
                result = new Cartesian3();
            }
            Cesium.Matrix4.inverseTransformation(this._actualModelMatrix, world2localMatrix)
            Cesium.Matrix4.multiplyByPoint(world2localMatrix, worldCoordinates, result);
            return result;
        },
        /**
       *局部坐标到世界坐标
       *@param {Cesium.Cartesian3}localCoordinates
       *@param {Cesium.Cartesian3}result
       *@return {Cesium.Cartesian3}
       */
        localToWorldCoordinates: function (localCoordinates, result) {
            if (!result) {
                result = new Cartesian3();
            }
            Cesium.Matrix4.multiplyByPoint(this._actualModelMatrix, localCoordinates, result);
            return result;
        },
        onModelMatrixNeedUpdate: function () {
            this._modelMatrixNeedsUpdate = true;
        },
        /**
         *
         *@param {Number}x
         *@param {Number}y
         *@param {Number}z
         */
        setPosition: function (x, y, z) {
            var changed = false;
            if (arguments.length == 1) {
                if (typeof x == 'number') {
                    if (x != this._position.x) changed = true;
                    this._position.x = x;
                } else if (x instanceof Cesium.Cartesian3) {
                    if (x != this._position.x
                        || y != this._position.y
                        || z != this._position.z) {
                        changed = true;
                    }

                    this._position.x = x.x;
                    this._position.y = x.y;
                    this._position.z = x.z;
                }
            }
            if (arguments.length == 2 && typeof y == 'number') {
                if (y != this._position.y) changed = true;
                this._position.y = y;
            }
            if (arguments.length == 3 && typeof z == 'number') {
                if (z != this._position.z) changed = true;
                this._position.z = z;
            }
            if (changed) {
                this._modelMatrixNeedsUpdate = true;
            }
        },
        /**
         *
         *@param {Number}x
         *@param {Number}y
         *@param {Number}z
         */
        setScale: function (x, y, z) {
            var changed = false;
            if (arguments.length == 1) {
                if (typeof x == 'number') {
                    if (x != this._scale.x) changed = true;
                    this._scale.x = x;
                } else if (x instanceof Cesium.Cartesian3) {
                    if (x != this._scale.x
                        || y != this._scale.y
                        || z != this._scale.z) {
                        changed = true;
                    }

                    this._scale.x = x.x;
                    this._scale.y = x.y;
                    this._scale.z = x.z;
                }
            }
            if (arguments.length == 2 && typeof y == 'number') {
                if (y != this._scale.y) changed = true;
                this._scale.y = y;
            }
            if (arguments.length == 3 && typeof z == 'number') {
                if (z != this._scale.z) changed = true;
                this._scale.z = z;
            }
            if (changed) {
                this._modelMatrixNeedsUpdate = true;
            }
        },

        toWireframe: function (geometry) {
            if (geometry.primitiveType !== Cesium.PrimitiveType.TRIANGLES
                && geometry.primitiveType !== Cesium.PrimitiveType.TRIANGLE_FAN
                && geometry.primitiveType !== Cesium.PrimitiveType.TRIANGLE_STRIP) {
                return geometry;
            }
            if (!geometry.triangleIndices) {
                geometry.triangleIndices = geometry.indices;
            }
            //if (geometry.lineIndices) {
            //    geometry.indices = geometry.lineIndices;
            //    return geometry;
            //}
            geometry = GeometryPipeline.toWireframe(geometry);
            //geometry.lineIndices = geometry.indices;
            return geometry;
        },

        restoreFromWireframe: function (geometry) {
            if (geometry.triangleIndices) {
                geometry.indices = geometry.triangleIndices;
            }
            geometry.primitiveType = Cesium.PrimitiveType.TRIANGLES;
            return geometry;
        },

        /**
        *
        *@param {Cesium.Mesh} mesh
        *@param {Cesium.FrameState} frameState
        *@return {Cesium.DrawCommand}
        *@private
        */
        createDrawCommand: function (mesh, frameState) {
            var that = this;
            var context = frameState.context;
            var geometry = mesh.geometry;
            var material = mesh.material;

            var command = new Cesium.DrawCommand({
                modelMatrix: Matrix4.clone(this.modelMatrix),
                owner: mesh,
                primitiveType: geometry.primitiveType,
                cull: material.cullFrustum,
                pass: material.translucent ? Cesium.Pass.TRANSLUCENT : Cesium.Pass.OPAQUE
                //,boundingVolume: geometry.boundingSphere
            });

            var attributeLocations = GeometryPipeline.createAttributeLocations(geometry);

            command.vertexArray = VertexArray.fromGeometry({
                context: context,
                geometry: geometry,
                attributeLocations: attributeLocations,
                bufferUsage: BufferUsage.STATIC_DRAW
            });
            command.vertexArray._attributeLocations = attributeLocations;

            var pickObject = {
                primitive: this,
                id: mesh
            };


            var pickId = context.createPickId(pickObject);
            that._pickIds.push(pickId);

            var pickColor = pickId.color;

            var shader = {
                fragmentShader: this.getFragmentShaderSource(material),
                vertexShader: this.getVertexShaderSource(geometry, material)
            };
            if (material.material3js) {
                shader = ShaderUtils.processShader3js(material.material3js, shader);

            }

            command._sp = ShaderProgram.fromCache({
                context: context,
                fragmentShaderSource: shader.fragmentShader,//this.getFragmentShaderSource(material),
                vertexShaderSource: shader.vertexShader,//this.getVertexShaderSource(geometry, material),
                attributeLocations: attributeLocations
            });
            if (!Cesium.defined(mesh.material.allowPick)) {
                mesh.material.allowPick = true;
            }
            if (mesh.material.allowPick) {
                command._pickSp = ShaderProgram.fromCache({
                    context: context,
                    fragmentShaderSource: 'void main() {\n\tgl_FragColor = vec4(' + pickColor.red + ',' + pickColor.green + ',' + pickColor.blue + ',' + pickColor.alpha + ');\n}',
                    vertexShaderSource: shader.vertexShader,
                    attributeLocations: attributeLocations
                });

            }
            command.shaderProgram = command._sp;
            command.renderState = this.getRenderState(material);

            command.uniformMap = this.getUniformMap(material, frameState);

            return command;
        },

        /**
        *
        *
        *@param {THREE.Material}material
        *@return {Cesium.RenderState}frameState
        *@private
        */
        getRenderState: function (material) {
            var renderState = {
                blending: material.blending ? BlendingState.ALPHA_BLEND : BlendingState.DISABLED,
                depthTest: {
                    enabled: material.depthTest,
                    func: DepthFunction.LESS
                },
                cull: {
                    enabled: true,
                    face: CullFace.FRONT
                },
                depthRange: {
                    near: 0,
                    far: 1
                },
                colorMask: {
                    red: true,
                    green: true,
                    blue: true,
                    alpha: true
                },
                depthMask: material.depthMask
            }
            renderState.cull.enabled = true;
            renderState.blending.color = {
                red: 0.0,
                green: 0.0,
                blue: 0.0,
                alpha: 0.0
            };
            switch (material.side) {
                case MeshMaterial.Sides.FRONT:
                    renderState.cull.face = CullFace.BACK;
                    break;
                case MeshMaterial.Sides.BACK:
                    renderState.cull.face = CullFace.FRONT;
                    break;
                default:
                    renderState.cull.enabled = false;
                    break;
            }

            renderState = RenderState.fromCache(renderState);

            return renderState;
        },
        /**
        *
        *
        *@param {THREE.Material}material
        *@param {Cesium.FrameState}frameState
        *@private
        */
        getUniformMap: function (material, frameState) {
            if (this._uniformMaps[material.uuid] && !material.needsUpdate) {
                return this._uniformMaps[material.uuid];

            }
            var uniformMap = {};
            this._uniformMaps[material.uuid] = uniformMap;

            material.needsUpdate = false;

            uniformMap.cameraPosition = function () {
                return frameState.camera.position;
            }
            uniformMap.u_cameraPosition = function () {
                return frameState.camera.position;
            }
            //base matrix
            uniformMap.u_normalMatrix = function () {
                return frameState.context.uniformState.normal;
            }
            uniformMap.u_projectionMatrix = function () {
                return frameState.context.uniformState.projection;
            }

            uniformMap.u_modelViewMatrix = function () {
                return frameState.context.uniformState.modelView;
            }
            //base matrix for threejs
            uniformMap.normalMatrix = function () {
                return frameState.context.uniformState.normal;
            }
            uniformMap.projectionMatrix = function () {
                return frameState.context.uniformState.projection;
            }

            uniformMap.modelViewMatrix = function () {
                return frameState.context.uniformState.modelView;
            }
            uniformMap.modelMatrix = function () {
                return frameState.context.uniformState.model;
            }
            uniformMap.u_modelMatrix = function () {
                return frameState.context.uniformState.model;
            }
            uniformMap.u_viewMatrix = function () {
                return frameState.context.uniformState.view;
            }
            uniformMap.viewMatrix = function () {
                return frameState.context.uniformState.view;
            }
            uniformMap.logDepthBufFC = function () {
                return 2.0 / (Math.log(frameState.camera.frustum.far + 1.0) / Math.LN2)
            }

            if (material.uniformStateUsed && material.uniformStateUsed.length) {
                material.uniformStateUsed.forEach(function (item) {
                    if (!uniformMap[item.glslVarName]) {
                        if (!frameState.context.uniformState[item.uniformStateName]) {
                            throw new Error(item.uniformStateName + "不是Cesium引擎的内置对象");
                        }
                        uniformMap[item.glslVarName] = function () {
                            return frameState.context.uniformState[item.uniformStateName];
                        }
                    }
                });
            }
            var that = this;

            function getCubeTextureCallback(name, item, mtl) {
                var callback = function () {
                    if (!that._textureCache[item.uuid] || item.needsUpdate) {
                        if (!callback.allLoaded && !callback.isLoading) {
                            var promises = [];
                            for (var i = 0; i < item.value.length; i++) {
                                if (item.value[i] instanceof HTMLCanvasElement
                                    || item.value[i] instanceof HTMLVideoElement
                                    || item.value[i] instanceof HTMLImageElement
                                ) {
                                    var deferred = Cesium.when.defer();
                                    requestAnimationFrame(function () {
                                        deferred.resolve(item.value[i]);
                                    });
                                    promises.push(deferred);
                                } else if (typeof item.value[i] === 'string') {
                                    promises.push(Cesium.loadImage(item.value[i]));
                                } else {
                                    throw Error(name + "" + i + "给定值“ " + item[i] + "” 不是有效的纹理图片");
                                }
                            }
                            callback.isLoading = true;
                            item.needsUpdate = false;
                            Cesium.when.all(promises, function (images) {

                                that._textureCache[item.uuid] = new Cesium.CubeMap({
                                    context: frameState.context,
                                    source: {
                                        positiveX: images[0],
                                        negativeX: images[1],
                                        positiveY: images[2],
                                        negativeY: images[3],
                                        positiveZ: images[4],
                                        negativeZ: images[5]
                                    }
                                });

                                callback.allLoaded = true;
                                callback.isLoading = false;
                            });
                        }
                    }
                    if (callback.allLoaded) {
                        return that._textureCache[item.uuid];
                    }
                    else {
                        if (!that.defaultCubeMap) {

                            if (!that.defaultTextureImage) {
                                that.defaultTextureImage = document.createElement("canvas");
                                that.defaultTextureImage.width = 1;
                                that.defaultTextureImage.height = 1;
                            }

                            that.defaultCubeMap = new Cesium.CubeMap({
                                context: frameState.context,
                                source: {
                                    positiveX: that.defaultTextureImage,
                                    negativeX: that.defaultTextureImage,
                                    positiveY: that.defaultTextureImage,
                                    negativeY: that.defaultTextureImage,
                                    positiveZ: that.defaultTextureImage,
                                    negativeZ: that.defaultTextureImage
                                }
                            });
                        }
                        return that.defaultCubeMap;
                    }
                }
                if (callback.allLoaded) {
                    callback.allLoaded = false;
                    callback.isLoading = false;
                }
                return callback;
            }


            function createTexture(texture, context) {

                var TextureMinificationFilter = Cesium.TextureMinificationFilter;
                var TextureWrap = Cesium.TextureWrap;

                var sampler = texture.sampler;

                var mipmap =
                    (sampler.minificationFilter === TextureMinificationFilter.NEAREST_MIPMAP_NEAREST) ||
                    (sampler.minificationFilter === TextureMinificationFilter.NEAREST_MIPMAP_LINEAR) ||
                    (sampler.minificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_NEAREST) ||
                    (sampler.minificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_LINEAR);
                var requiresNpot = mipmap ||
                    (sampler.wrapS === TextureWrap.REPEAT) ||
                    (sampler.wrapS === TextureWrap.MIRRORED_REPEAT) ||
                    (sampler.wrapT === TextureWrap.REPEAT) ||
                    (sampler.wrapT === TextureWrap.MIRRORED_REPEAT);

                var source = texture.source;
                var npot = !CesiumMath.isPowerOfTwo(source.width) || !CesiumMath.isPowerOfTwo(source.height);

                if (requiresNpot && npot) {
                    // WebGL requires power-of-two texture dimensions for mipmapping and REPEAT/MIRRORED_REPEAT wrap modes.
                    var canvas = document.createElement('canvas');
                    canvas.width = CesiumMath.nextPowerOfTwo(source.width);
                    canvas.height = CesiumMath.nextPowerOfTwo(source.height);
                    var canvasContext = canvas.getContext('2d');
                    canvasContext.drawImage(source, 0, 0, source.width, source.height, 0, 0, canvas.width, canvas.height);
                    source = canvas;
                }

                var tx;

                if (texture.target === WebGLConstants.TEXTURE_2D) {
                    tx = new Texture({
                        context: context,
                        source: source,
                        width: texture.width,
                        height: texture.height,
                        pixelFormat: texture.internalFormat,
                        pixelDatatype: texture.type,
                        sampler: sampler,
                        flipY: texture.flipY
                    });
                }
                // GLTF_SPEC: Support TEXTURE_CUBE_MAP.  https://github.com/KhronosGroup/glTF/issues/40

                if (mipmap) {
                    tx.generateMipmap();
                }

                return tx;
            }
            var WebGLConstants = Cesium.WebGLConstants;
            function onTextureImageLoaded(image, item) {
                var tex;
                if (defined(image.internalFormat)) {
                    tex = new Texture({
                        context: frameState.context,
                        pixelFormat: image.internalFormat,
                        width: image.width,
                        height: image.height,
                        source: {
                            arrayBufferView: image.bufferView
                        },
                        flipY: item.flipY
                    });
                } else {
                    var format = Cesium.WebGLConstants.RGB;
                    if (image instanceof HTMLCanvasElement
                        || image instanceof HTMLVideoElement
                        || (image.src && image.src.toLocaleLowerCase().indexOf(".png") >= 0)
                    ) {
                        format = Cesium.WebGLConstants.RGBA;
                    }
                    if (item.sampler) {
                        tex = createTexture({
                            context: frameState.context,
                            source: image,
                            target: WebGLConstants.TEXTURE_2D,
                            width: item.width,
                            height: item.height,
                            pixelFormat: format,
                            flipY: item.flipY,
                            sampler: new Cesium.Sampler(item.sampler)
                        }, frameState.context);
                    } else {
                        tex = new Texture({
                            context: frameState.context,
                            source: image,
                            target: WebGLConstants.TEXTURE_2D,
                            width: item.width,
                            height: item.height,
                            pixelFormat: format,
                            flipY: Cesium.defined(item.flipY) ? item.flipY : true
                        });
                    }
                }
                return tex;
            }

            function getTextureCallback(item) {

                var callback = function () {

                    if (!that._textureCache[item.value] || item.needsUpdate) {

                        if (item.value instanceof HTMLImageElement
                            || item.value instanceof HTMLCanvasElement
                            || item.value instanceof HTMLVideoElement
                        ) {
                            var image = item.value;
                            that._textureCache[item.value] = onTextureImageLoaded(image, item);
                            item.needsUpdate = false;
                            return that._textureCache[item.value];

                        } else {
                            if (typeof item.value === "string" && !callback.isLoading) {
                                callback.isLoading = true;
                                item.needsUpdate = false;
                                var url = item.value.toLocaleLowerCase();

                                var extension = Path.GetExtension(url).slice(1);
                                if (extension == 'tif') {//处理tif纹理

                                    Cesium.Resource.fetchArrayBuffer({ url: url }).then(function (imageArrayBuffer) {
                                        var tiffParser = new TIFFParser();
                                        var tiffCanvas = tiffParser.parseTIFF(imageArrayBuffer);
                                        if (that._textureCache[item.value]) {
                                            that._textureCache[item.value].destroy && that._textureCache[item.value].destroy();
                                        }
                                        that._textureCache[item.value] = onTextureImageLoaded(tiffCanvas, item);
                                        callback.isLoading = false;

                                    }).catch(function (err) {
                                        console.log(err);
                                    })

                                } else {
                                    Cesium.Resource.fetchImage({ url: item.value }).then(function (image) {
                                        if (that._textureCache[item.value]) {
                                            that._textureCache[item.value].destroy && that._textureCache[item.value].destroy();
                                        }
                                        that._textureCache[item.value] = onTextureImageLoaded(image, item);
                                        callback.isLoading = false;
                                    }).catch(function (err) {
                                        console.log(err);
                                    })
                                }
                            }

                            if (!that.defaultTextureImage) {
                                that.defaultTextureImage = document.createElement("canvas");
                                that.defaultTextureImage.width = 1;
                                that.defaultTextureImage.height = 1;
                            }
                            if (!that.defaultTexture) {
                                that.defaultTexture = new Texture({
                                    context: frameState.context,
                                    source: that.defaultTextureImage
                                });
                            }

                            return that.defaultTexture;
                        }

                    } else {
                        return that._textureCache[item.value];
                    }

                }

                return callback;
            }

            if (material.uniforms) {

                function setUniformCallbackFunc(name, item) {

                    if (item !== undefined && item !== null) {//item may be 0
                        var isImageUrl = typeof item.value === "string";
                        var isCssColorString = typeof item.value === "string";
                        if (typeof item.value === "string") {
                            var itemLowerCase = item.value.toLocaleLowerCase();
                            if (itemLowerCase.endsWith(".png")
                                || itemLowerCase.endsWith(".jpg")
                                || itemLowerCase.endsWith(".bmp")
                                || itemLowerCase.endsWith(".gif")
                                || itemLowerCase.endsWith(".tif")
                                || itemLowerCase.endsWith(".tiff")
                                || itemLowerCase.startsWith("data:")
                            ) {
                                isImageUrl = true;
                                isCssColorString = false;
                            } else {
                                try {
                                    Cesium.Color.fromCssColorString(item.value);
                                    isImageUrl = true;
                                    isCssColorString = false;
                                } catch (e) {
                                    isImageUrl = false;
                                    isCssColorString = false;
                                }
                            }
                        }

                        if (item.value instanceof Cesium.Cartesian2
                            || item.value instanceof Cesium.Cartesian3
                            || item.value instanceof Cesium.Cartesian4
                            || item.value instanceof Cesium.Color
                            || item.value instanceof Cesium.Matrix4
                            || item.value instanceof Cesium.Matrix3
                            || item.value instanceof Cesium.Matrix2
                            || item.value instanceof Cesium.Texture
                            || typeof item.value === "number"
                            || isCssColorString
                            || item.value instanceof Cesium.Texture
                            || (item.value instanceof Array && (typeof item.value[0] === 'number'
                                || item.value[0] instanceof Cesium.Cartesian2
                                || item.value[0] instanceof Cesium.Cartesian3
                                || item.value[0] instanceof Cesium.Cartesian4))
                        ) {
                            if (!that._uniformValueCache) {
                                that._uniformValueCache = {};
                            }
                            that._uniformValueCache[item.uuid] = item;
                            if (isCssColorString) {
                                item.value = Cesium.Color.fromCssColorString(item.value);
                            }
                            uniformMap[name] = function () {
                                return that._uniformValueCache[item.uuid].value;
                            }
                        } else if (item.value instanceof Array && item.value.length == 6) {
                            uniformMap[name] = getCubeTextureCallback(name, item);
                        } else if (isImageUrl
                            || item.value instanceof HTMLImageElement
                            || item.value instanceof HTMLCanvasElement
                            || item.value instanceof HTMLVideoElement
                        ) {
                            uniformMap[name] = getTextureCallback(item, material);
                        } else if (item.value instanceof FramebufferTexture) {
                            if (!that._renderToTextureCommands) {
                                that._renderToTextureCommands = [];
                            }
                            if (!that._framebufferTextures[item.uuid]) {
                                that._framebufferTextures[item.uuid] = item;
                            }
                            uniformMap[name] = function () {
                                if (!that._framebufferTextures[item.uuid]
                                    || !that._framebufferTextures[item.uuid].value.texture) {
                                    return frameState.context.defaultTexture;
                                }
                                return that._framebufferTextures[item.uuid].value.texture;
                            }
                        }
                    }
                }

                var uniforms = material.uniforms;
                for (var name in uniforms) {

                    if (uniforms.hasOwnProperty(name) && Cesium.defined(uniforms[name].value) && uniforms[name].value != null) {
                        if (Array.isArray(uniforms[name].value) && uniforms[name].value.length == 0) {
                            continue;
                        }
                        var item = uniforms[name];
                        if (item == undefined || item == null) {
                            continue;
                        }
                        setUniformCallbackFunc(name, item);
                    }
                }
            }

            return this._uniformMaps[material.uuid];
        },
        /**
        *
        *@param {Cesium.Geometry} geometry
        *@param {Cesium.Material} material
        *@return {String}
        *@private
        */
        getVertexShaderSource: function (geometry, material) {

            function getAttributeDefineBlok(userDefine) {
                var glsl = "";
                var attrs = geometry.attributes;
                for (var name in attrs) {

                    if (attrs.hasOwnProperty(name)) {
                        var attr = attrs[name]
                        if (attr) {

                            var type = null;
                            switch (attr.componentsPerAttribute) {
                                case 1:
                                    type = "float";
                                    break;
                                case 2:
                                    type = "vec2";
                                    break;
                                case 3:
                                    type = "vec3";
                                    break;
                                case 4:
                                    type = "vec4";
                                    break;
                                default:
                            }

                            if (type) {
                                if (userDefine.indexOf("attribute " + type + " " + name) >= 0) {
                                    continue;
                                }
                                glsl += "attribute " + type + " " + name + ";\n";
                            }

                        }
                    }
                }
                return glsl;
            }

            var uniforms = "\n\
        uniform mat4 modelViewMatrix;\n\
        uniform mat4 viewMatrix;\n\
        uniform mat4 modelMatrix;\n\
        uniform mat4 projectionMatrix;\n\
        uniform mat3 normalMatrix;\n\
        uniform mat4 u_modelViewMatrix;\n\
        uniform mat4 u_viewMatrix;\n\
        uniform mat4 u_modelMatrix;\n\
        uniform mat4 u_projectionMatrix;\n\
        uniform mat3 u_normalMatrix;\n\
        uniform vec3 cameraPosition;\n\
        uniform vec3 u_cameraPosition;\n";

            var innerUniforms = [
                "uniform mat4 modelViewMatrix",
                "uniform mat4 modelMatrix",
                "uniform mat4 projectionMatrix",
                "uniform mat3 normalMatrix",
                "uniform mat4 u_modelViewMatrix",
                "uniform mat4 u_modelMatrix",
                "uniform mat4 u_projectionMatrix",
                "uniform mat3 u_normalMatrix",
                "uniform mat4 u_viewMatrix",
                "uniform mat4 viewMatrix",
                "uniform vec3 cameraPosition",
                "uniform vec3 u_cameraPosition"
            ];
            if (material.vertexShader) {
                uniforms = "";
                innerUniforms.forEach(function (item) {
                    if (material.vertexShader.indexOf(item) < 0) {
                        uniforms += item + ";\n";
                    }
                });
                var vs = getAttributeDefineBlok(material.vertexShader) + uniforms +
                    material.vertexShader;

                vs = ShaderChunk.parseIncludes(vs);

                return vs;
            }
            else {
                throw new Error("material.vertexShader 是必须参数");
            }
        },
        /**
         *
         *@param {Cesium.Material} material
         *@return {String}
         *@private
         */
        getFragmentShaderSource: function (material) {

            if (material.fragmentShader) {
                var fs = ShaderChunk.parseIncludes(material.fragmentShader);
                return fs;
            } else {
                throw new Error("material.fragmentShader 是必须参数");
            }
        }
    }

    MeshVisualizer.prototype._computeModelMatrix = function (mesh, frameState) {
        if (mesh._actualMesh) {
            mesh = mesh._actualMesh;
        }
        var that = this;
        if (mesh instanceof LOD || mesh instanceof ReferenceMesh || typeof mesh.update === 'function') {
            if (mesh.parent) {
                if (mesh.parent == that) {
                    mesh.update(that._actualModelMatrix, frameState);

                } else if (mesh.parent.modelMatrix) {
                    mesh.update(mesh.parent.modelMatrix, frameState);
                } else {
                    mesh.update(that._actualModelMatrix, frameState);
                }
            } else {
                mesh.update(that._actualModelMatrix, frameState);
            }
        } else {
            var position = mesh.position;
            if (mesh.parent instanceof LOD) {
                Matrix4.clone(mesh.parent.modelMatrix, mesh.modelMatrix);

            } else if (mesh._modelMatrixNeedsUpdate) {
                var rotation = mesh.quaternion ? mesh.quaternion : mesh.rotation;

                if (mesh.parent && mesh.parent.modelMatrix) {

                    var actualModelMatrix = mesh.parent.modelMatrix ? mesh.parent.modelMatrix : mesh._drawCommand.modelMatrix;
                    RendererUtils.computeModelMatrix(
                        actualModelMatrix,
                        mesh.position,
                        rotation,
                        mesh.scale,
                        mesh.modelMatrix
                    );

                } else {
                    RendererUtils.computeModelMatrix(
                        that._actualModelMatrix,
                        mesh.position,
                        rotation,
                        mesh.scale,
                        mesh.modelMatrix
                    );
                }

                mesh._modelMatrixNeedsUpdate = false;
            }
        }
    }
    /**
    *
    *@param {Cesium.FrameState}frameState
    */
    MeshVisualizer.prototype.update = function (frameState) {
        if (!this._scene) {
            this._scene = frameState.camera._scene;
        }
        if (!this._ready || !this.show && this._chidren.length > 0) {//如果未准备好则不加入渲染队列
            return;
        }
        this.beforeUpdate.raiseEvent(frameState);

        var that = this;
        var wireframeChanged = false;
        var sysWireframe = frameState.camera._scene._globe._surface.tileProvider._debug.wireframe;
        if (this.debug) {
            sysWireframe = true;
        }

        if (sysWireframe != this._isWireframe) {
            wireframeChanged = true;
        }
        if (this._modelMatrixNeedsUpdate) {
            this._actualModelMatrix = RendererUtils.computeModelMatrix(
                this._modelMatrix,
                this._position,
                this._rotation,
                this._scale,
                this._actualModelMatrix
            );
            if (this._up && this._up.y) {
                this._actualModelMatrix = RendererUtils.yUp2Zup(this._actualModelMatrix, this._actualModelMatrix);
            }
            Cesium.Cartesian3.clone(this._scale, this._oldScale);
            Cesium.Cartesian3.clone(this._position, this._oldPosition);
            this._modelMatrixNeedsUpdate = false;
        }

        MeshVisualizer.traverse(this, function (mesh) {

            if (MeshUtils.isMesh3js(mesh)) {
                var needsUpdate = !mesh._actualMesh
                    || mesh.needsUpdate
                    || mesh.geometry.needsUpdate;

                if (needsUpdate) {
                    mesh._actualMesh = MeshUtils.fromMesh3js(mesh);
                    mesh.modelMatrixNeedsUpdate = true;
                }
                if (!needsUpdate) {
                    for (var pn in mesh.geometry.attributes) {
                        if (mesh.geometry.attributes.hasOwnProperty(pn)) {
                            mesh._actualMesh.geometry.attributes[pn].needsUpdate = mesh.geometry.attributes[pn].needsUpdate;
                        }
                    }
                    var index = mesh.geometry.index;
                    if (index && index.needsUpdate) {
                        mesh._actualMesh.geometry.needsUpdate = true;
                    }
                }

                mesh._actualMesh.quaternion = Cesium.Quaternion.clone(mesh.quaternion);
                mesh._actualMesh.position = mesh.position;
                mesh._actualMesh.scale = mesh.scale;
                mesh._actualMesh.modelMatrixNeedsUpdate = mesh.modelMatrixNeedsUpdate;
                mesh = mesh._actualMesh;
                MaterialUtils.updateMaterialFrom3js(mesh.material);
            }


            that._computeModelMatrix(mesh, frameState);

            if (typeof mesh.update !== 'function') {
                if (frameState.passes.pick && !mesh.material.allowPick) {
                    return;
                }

                if (!mesh._drawCommand
                    || mesh.needsUpdate
                    || mesh.geometry.needsUpdate
                    || wireframeChanged
                ) {//重新构建绘图命令，比如geometry完全不同于之前一帧 或者顶点和索引数量都发生改变等时，执行这段

                    if (sysWireframe || mesh.material.wireframe) {
                        that.toWireframe(mesh.geometry);
                    } else {
                        that.restoreFromWireframe(mesh.geometry);
                    }

                    mesh._drawCommand = that.createDrawCommand(mesh, frameState);

                    mesh.needsUpdate = false;
                    mesh.geometry.needsUpdate = false;
                } else {//在不需要重新构建绘图命令时，检查各个属性和索引是否需要更新，需要则将更新相应的缓冲区

                    //更新属性缓冲区
                    for (var name in mesh.geometry.attributes) {
                        if (mesh.geometry.attributes.hasOwnProperty(name)) {
                            if (mesh.geometry.attributes[name] && mesh.geometry.attributes[name].needsUpdate) {
                                var attrLocation = mesh._drawCommand.vertexArray._attributeLocations[name]
                                var vb = mesh._drawCommand.vertexArray._attributes[attrLocation].vertexBuffer;
                                vb.copyFromArrayView(mesh.geometry.attributes[name].values, 0);
                            }
                        }
                    }
                    //更新索引缓冲区
                    if (mesh.geometry.indexNeedsUpdate) {
                        var vb = mesh._drawCommand.vertexArray.indexBuffer;
                        vb.copyFromArrayView(mesh.geometry.indices, 0);
                    }
                }
                mesh._drawCommand.modelMatrix = mesh.modelMatrix;
                if (!mesh._drawCommand.boundingVolume) {
                    if (!mesh.geometry.boundingSphere) {
                        mesh.geometry.boundingSphere = Cesium.BoundingSphere.fromVertices(mesh.geometry.attributes.position.values);
                    }
                    mesh._drawCommand.boundingVolume = Cesium.BoundingSphere.clone(mesh.geometry.boundingSphere);
                }
                Cesium.Matrix4.getTranslation(mesh.modelMatrix, mesh._drawCommand.boundingVolume.center);

                mesh._drawCommand.uniformMap = that.getUniformMap(mesh.material, frameState);
                if (frameState.passes.pick) {

                    mesh._drawCommand.shaderProgram = mesh._drawCommand._pickSp;
                    frameState.commandList.push(mesh._drawCommand);


                } else {
                    mesh._drawCommand.renderState.depthTest.enabled = mesh.material.depthTest;
                    mesh._drawCommand.shaderProgram = mesh._drawCommand._sp;
                    frameState.commandList.push(mesh._drawCommand);
                }


            } else {
                mesh.needsUpdate = false;
            }

        }, true);

        //执行帧缓冲绘图命令
        for (var i in that._framebufferTextures) {
            if (that._framebufferTextures.hasOwnProperty(i)) {
                var item = that._framebufferTextures[i].value;
                that.updateFrameBufferTexture(frameState, item);
            }
        }

        this._isWireframe = sysWireframe;
        wireframeChanged = false;
        this._modelMatrixNeedsUpdate = false;
        this._geometryChanged = false;

    }

    /**
    *单独渲染frameBufferTexture中的mesh，最终更新frameBufferTexture中的texture
    *@param {Cesium.FrameState}frameState
    *@param {Cesium.FramebufferTexture}frameBufferTexture
    */
    MeshVisualizer.prototype.updateFrameBufferTexture = function (frameState, frameBufferTexture,viewport) {
        var that = this;

        var item = frameBufferTexture;
        if (item instanceof FramebufferTexture) {

            item.drawCommands = [];
            MeshVisualizer.traverse(item.mesh, function (mesh) {
                if (MeshUtils.isMesh3js(mesh)) {
                    var needsUpdate = !mesh._actualMesh
                        || mesh.needsUpdate
                        || mesh.geometry.needsUpdate;

                    if (needsUpdate) {
                        mesh._actualMesh = MeshUtils.fromMesh3js(mesh);
                    }
                    if (!needsUpdate) {
                        for (var pn in mesh.geometry.attributes) {
                            if (mesh.geometry.attributes.hasOwnProperty(pn)) {
                                mesh._actualMesh.geometry[pn].needsUpdate = mesh.geometry.attributes[pn].needsUpdate;
                            }
                        }
                        var index = mesh.geometry.getIndex();
                        if (index && index.needsUpdate) {
                            mesh._actualMesh.geometry.needsUpdate = true;
                        }
                    }

                    mesh._actualMesh.quaternion = Cesium.Quaternion.clone(mesh.quaternion);
                    mesh._actualMesh.position = mesh.position;
                    mesh._actualMesh.scale = mesh.scale;
                    mesh._actualMesh.modelMatrixNeedsUpdate = mesh.modelMatrixNeedsUpdate;
                    mesh = mesh._actualMesh;
                    MaterialUtils.updateMaterialFrom3js(mesh.material);
                }
                that._computeModelMatrix(mesh, frameState);

                if (!mesh._textureCommand
                    || mesh.needsUpdate
                    || mesh.geometry.needsUpdate
                ) {
                    if (mesh.material.wireframe) {
                        that.toWireframe(mesh.geometry);
                    } else {
                        that.restoreFromWireframe(mesh.geometry);
                    }

                    mesh._textureCommand = that.createDrawCommand(mesh, frameState);
                    //mesh._textureCommand.boundingVolume = mesh.geometry.boundingSphere;
                    mesh.needsUpdate = false;
                    mesh.material.needsUpdate = false;

                } else {//在不需要重新构建绘图命令时，检查各个属性和索引是否需要更新，需要则将更新相应的缓冲区

                    //更新属性缓冲区
                    for (var name in mesh.geometry.attributes) {
                        if (mesh.geometry.attributes.hasOwnProperty(name)
                            && mesh.geometry.attributes[name]) {

                            if (mesh.geometry.attributes[name] && mesh.geometry.attributes[name].needsUpdate) {
                                var attrLocation = mesh._textureCommand.vertexArray._attributeLocations[name]
                                var vb = mesh._textureCommand.vertexArray._attributes[attrLocation].vertexBuffer;
                                vb.copyFromArrayView(mesh.geometry.attributes[name].values, 0);
                            }
                        }
                    }
                    //更新索引缓冲区
                    if (mesh.geometry.indexNeedsUpdate) {
                        var vb = mesh._textureCommand.vertexArray.indexBuffer;
                        vb.copyFromArrayView(mesh.geometry.indices, 0);
                    }
                }

                mesh._textureCommand.modelMatrix = mesh.modelMatrix;

                var context = frameState.context;
                var drawingBufferWidth = context.drawingBufferWidth;
                var drawingBufferHeight = context.drawingBufferHeight;
                if (!item.texture
                    || item.texture.width != drawingBufferWidth
                    || item.texture.height != drawingBufferHeight
                ) {
                    var notFullScreen = item._notFullScreen || Cesium.defined(item.texture);
                    if (!notFullScreen) {
                        item.texture = new Texture({
                            context: context,
                            width: drawingBufferWidth,
                            height: drawingBufferHeight,
                            pixelFormat: PixelFormat.RGBA
                        });
                    }
                    item._notFullScreen = notFullScreen;
                }
                mesh._textureCommand.renderState.depthTest.enabled = mesh.depthTest;
                if (viewport) {
                    mesh._textureCommand.renderState.viewport = viewport;
                }
                item.drawCommands.push(mesh._textureCommand);

            }, true);

            RendererUtils.renderToTexture(item.drawCommands, frameState, item.texture);
        }

    }
    /**
    *
    *@param {Cesium.Mesh}mesh
    */
    MeshVisualizer.prototype.add = function (mesh) {
        this._chidren.push(mesh);
    }

    /**
    *
    */
    MeshVisualizer.prototype.destroy = function () {
        this._ready = false;
        MeshVisualizer.traverse(this, function (mesh) {
            if (mesh._drawCommand) {
                delete mesh._drawCommand;
            }
        }, false);
        for (var i in this._uniformValueCache) {
            if (this._uniformValueCache.hasOwnProperty(i)) {
                delete this._uniformValueCache[i];
            }
        }
        for (var i in this._textureCache) {
            if (this._textureCache.hasOwnProperty(i)) {
                delete this._textureCache[i];
            }
        }
        for (var i in this._uniformMaps) {
            if (this._uniformMaps.hasOwnProperty(i)) {
                delete this._uniformMaps[i];
            }
        }
        for (var i in this._framebufferTextures) {
            if (this._framebufferTextures.hasOwnProperty(i)) {
                delete this._framebufferTextures[i];
            }
        }
        this._uniformValueCache = {};
        this._textureCache = {};
        this._uniformMaps = {};
        this._framebufferTextures = {};
        if (this._pickIds) {
            for (i = 0; i < this._pickIds.length; ++i) {
                this._pickIds[i].destroy && this._pickIds[i].destroy();
            }
        }
    }

    /**
    *
    *遍历节点
    *@param {Cesium.MeshVisualizer|Cesium.Mesh}root
    *@param {Cesium.MeshVisualizer~TraverseCallback}traverseFunc 访问每个节点时回调该函数，进行相关操作。回调函数包含一个参数，traverseArgs，其中封装了一个属性cancelCurrent，可以通过改变此属性达到终止遍历当前节点的子节点
    *@param {Boolean}visibleOnly visibleOnly为true时仅遍历可见的节点，如果父级节点不可见则不再访问其子节点
    */
    MeshVisualizer.traverse = function (node, traverseFunc, visibleOnly, scratchTraverseArgs) {
        if (!node) {
            return;
        }
        if (!scratchTraverseArgs) {
            scratchTraverseArgs = {
                cancelCurrent: false,
                cancelAll: false
            };
        }
        scratchTraverseArgs.cancelCurrent = false;
        if (visibleOnly && (!node.show && !node.visible)) {
            return;
        }
        if ((node.geometry && node.material) || node instanceof LOD || node instanceof ReferenceMesh) {
            traverseFunc(node, scratchTraverseArgs);
        }

        if (node.children) {
            for (var i = 0; i < node.children.length; i++) {
                if (scratchTraverseArgs.cancelCurrent) {
                    continue;
                }
                if (scratchTraverseArgs.cancelAll) {
                    break;
                }
                MeshVisualizer.traverse(node.children[i], traverseFunc, visibleOnly, scratchTraverseArgs);
            }
        }
    },

    /**
    *
    *@Cesium.MeshVisualizer~TraverseCallback
    *@param {Cesium.Mesh|Cesium.LOD|Cesium.MeshVisualizer|Object}node
    *@param {Object}traverseArgs
    *@param {Boolean}traverseArgs.cancelCurrent 为true时终止遍历当前节点的子节点
    *@param {Boolean}traverseArgs.cancelAll 为true时终止遍历，退出遍历循环
    */


        Object.defineProperties(MeshVisualizer.prototype, {
            scene: {
                set: function (val) {
                    this._scene = val;
                },
                get: function () {
                    return this._scene;
                }
            },
            frameState: {
                get: function () {
                    if (!this._scene) {
                        return undefined;
                    }
                    return this._scene.frameState;
                }
            },
            modelMatrixNeedsUpdate: {
                get: function () {
                    return this._modelMatrixNeedsUpdate;
                },
                set: function (val) {
                    this._modelMatrixNeedsUpdate = val;
                    if (val) {
                        MeshVisualizer.traverse(this, function (child) {
                            child._modelMatrixNeedsUpdate = val;
                        }, false);
                    }
                }
            },
            showReference: {
                get: function () {
                    return this.referenceMesh.show;
                },
                set: function (val) {
                    this.referenceMesh.show = val;
                }
            },
            children: {
                get: function () {
                    return this._chidren;
                },
                set: function (val) {
                    this._chidren = val;
                }
            },
            show: {
                get: function () {
                    return this._show;
                },
                set: function (val) {
                    this._show = val;
                }
            },
            debug: {
                get: function () {
                    return this._debug;
                },
                set: function (val) {
                    this._debug = val;
                }
            },
            ready: {
                get: function () {
                    return this._ready;
                }
            },
            modelMatrix: {
                get: function () {
                    return this._modelMatrix;
                },
                set: function (val) {
                    this._modelMatrix = val;
                    this._modelMatrixNeedsUpdate = true;
                }
            },
            rotation: {
                get: function () {
                    return this._rotation;
                },
                set: function (val) {
                    if (val != this._rotation) {
                        this._rotation = val;
                        this._needUpdate = true;
                    }
                    this._rotation.paramChanged.removeEventListener(this._onNeedUpdateChanged);
                    this._rotation = val;
                    this._rotation.paramChanged.addEventListener(this._onNeedUpdateChanged);
                }
            },
            position: {
                get: function () {
                    return this._position;
                },
                set: function (val) {
                    if (val.x != this._position.x || val.y != this._position.y || val.z != this._position.z) {
                        this._position = val;
                        this._modelMatrixNeedsUpdate = true;
                    }
                    this._position = val;
                }
            },
            scale: {
                get: function () {
                    return this._scale;
                },
                set: function (val) {
                    if (val.x != this._scale.x || val.y != this._scale.y || val.z != this._scale.z) {
                        this._scale = val;
                        this._modelMatrixNeedsUpdate = true;
                    }
                    this._scale = val;
                }
            }
        });
    return MeshVisualizer;
});
define('Core/BasicMeshMaterial',[
    'Core/MeshMaterial',
    'Core/Shaders/ShaderChunk',
    'Core/Shaders/ShaderLib',
    'Util/Path'
], function (
    MeshMaterial,
    ShaderChunk,
    ShaderLib,
    Path
    ) {
    var WebGLConstants = Cesium.WebGLConstants;
    function BasicMeshMaterial(options) {
        options = options ? options : {};

        options.uniforms = options.uniforms ? options.uniforms : {
            ambientColor: [0, 0, 0, 1.0],               // Ka
            emissionColor: [0, 0, 0, 1.0],              // Ke
            diffuseColor: [0, 0, 0, 1.0],               // Kd
            specularColor: [0, 0, 0, 1.0],              // Ks
            specularShininess: 0,          // Ns
            alpha: undefined,                      // d / Tr
            ambientColorMap: undefined,            // map_Ka
            emissionColorMap: undefined,           // map_Ke
            diffuseColorMap: undefined,            // map_Kd
            specularColorMap: undefined,           // map_Ks
            specularShininessMap: undefined,       // map_Ns
            normalMap: undefined,                  // map_Bump
            alphaMap: undefined                    // map_d
        };
        options.uniforms.ambientColor = Cesium.defaultValue(options.uniforms.ambientColor, [0, 0, 0, 1.0]);
        options.uniforms.emissionColor = Cesium.defaultValue(options.uniforms.emissionColor, [0, 0, 0, 1.0]);
        options.uniforms.diffuseColor = Cesium.defaultValue(options.uniforms.diffuseColor, [0, 0, 0, 1.0]);
        options.uniforms.specularColor = Cesium.defaultValue(options.uniforms.specularColor, [0, 0, 0, 1.0]);
        options.uniforms.alpha = Cesium.defaultValue(options.uniforms.alpha, 1);
        options.uniforms.specularShininess = Cesium.defaultValue(options.uniforms.specularShininess, 0);
        options.side = Cesium.defaultValue(options.side, MeshMaterial.Sides.FRONT)

        MeshMaterial.apply(this, [options]);
        this.blendEnable = false;
        var withTexture = options.withTexture;
        var withNormals = options.withNormals;
        this.depthTest = true;
        this.depthMask = true;
        this.blending = true;
        if (options.uniforms.diffuseColorMap) {//&& options.uniforms.diffuseColorMap.toLowerCase().indexOf(".png")) {

            if (typeof options.uniforms.diffuseColorMap === 'string') {
                var diffuseColorMap = options.uniforms.diffuseColorMap.toLowerCase();
                var extension = Path.GetExtension(diffuseColorMap);
                if (extension == ".tif" || extension == ".png") {
                    this.translucent = true;
                } else if (diffuseColorMap.slice(0, "data:image/png".length) === "data:image/png") {
                    this.translucent = true;
                } else if (diffuseColorMap.slice(0, "data:image/tif".length) === "data:image/tif") {
                    this.translucent = true;
                }
            } else if (diffuseColorMap instanceof HTMLCanvasElement
                       || diffuseColorMap instanceof HTMLVideoElement
                ) {
                this.translucent = true;
            }
            withTexture = true;
            if (!Cesium.defined(this.uniforms.diffuseColorMap.flipY)) {
                this.uniforms.diffuseColorMap.flipY = false;
            }

            if (!this.uniforms.diffuseColorMap.sampler) {
                var sampler = {};

                sampler.magnificationFilter = WebGLConstants.LINEAR;
                sampler.minificationFilter = WebGLConstants.NEAREST_MIPMAP_LINEAR;
                sampler.wrapS = WebGLConstants.REPEAT;
                sampler.wrapT = WebGLConstants.REPEAT;
                this.uniforms.diffuseColorMap.sampler = sampler;
            }

        } else {
            withTexture = false;
        }

        var vertexShaderUri = null;// "texture_normals.vert";
        var fragmentShaderUri = null;  //"texture_normals.frag";
        if (withTexture && withNormals) {
            vertexShaderUri = ShaderChunk.texture_normals_vert;// "texture_normals.vert";
            fragmentShaderUri = ShaderChunk.texture_normals_frag;  //"texture_normals.frag";
        } else if (withTexture && !withNormals) {
            vertexShaderUri = ShaderChunk.texture_vert;//"texture.vert";
            fragmentShaderUri = ShaderChunk.texture_frag;// "texture.frag";
        } else if (!withTexture && withNormals) {
            vertexShaderUri = ShaderChunk.normals_vert;// "normals.vert";
            fragmentShaderUri = ShaderChunk.normals_frag;//"normals.frag";
        }
        else {
            vertexShaderUri = ShaderChunk.none_vert;// "none.vert";
            fragmentShaderUri = ShaderChunk.none_frag;// "none.frag";
        }
        this.vertexShader = vertexShaderUri;
        this.fragmentShader = fragmentShaderUri;


    }
    BasicMeshMaterial.prototype = new MeshMaterial();
    return BasicMeshMaterial;
});
define('Core/BasicGeometry',[], function () {

    /**
    *
    *@param {Object}options
    *@param {Array<Number>|Float32Array}options.positions
    *@param {Array<Number>|Int32Array}options.indices
    *@param {Array<Number>|Float32Array}[options.normals]
    *@param {Array<Number>|Float32Array}[options.uvs]
    *
    *@memberof Cesium
    *@constructor
    */
    function BasicGeometry(options) {
        this.positions = options.positions;
        this.normals = options.normals;
        this.uvs = options.uvs;
        this.indices = options.indices;
    }
    /**
    *
    *@param {Cesium.BasicGeometry}basicGeometry
    *@return {Cesiumm.Geometry}
    */
    BasicGeometry.createGeometry = function (basicGeometry) {
        if (!basicGeometry.positions) {
            throw new Error("缺少positions参数");
        }
        if (!basicGeometry.indices) {
            throw new Error("缺少indices参数");
        }
        var positions = basicGeometry.positions;
        var normals = basicGeometry.normals;
        var uvs = basicGeometry.uvs;
        var indices = basicGeometry.indices instanceof Int32Array ? basicGeometry.indices : new Int32Array(basicGeometry.indices);

        var attributes = {
            position: new Cesium.GeometryAttribute({
                componentDatatype: Cesium.ComponentDatatype.DOUBLE,
                componentsPerAttribute: 3,
                values: positions instanceof Float32Array ? positions : new Float32Array(basicGeometry.positions)
            })
        };
        if (normals) {
            attributes.normal = new Cesium.GeometryAttribute({
                componentDatatype: Cesium.ComponentDatatype.FLOAT,
                componentsPerAttribute: 3,
                values: normals instanceof Float32Array ? normals : new Float32Array(normals)
            })
        }
        if (uvs) {
            attributes.uv = new Cesium.GeometryAttribute({
                componentDatatype: Cesium.ComponentDatatype.FLOAT,
                componentsPerAttribute: 2,
                values: uvs instanceof Float32Array ? uvs : new Float32Array(uvs)
            })
        }


        var bs = Cesium.BoundingSphere.fromVertices(positions);
        var geo = new Cesium.Geometry({
            attributes: attributes,
            indices: new Int32Array(indices),
            primitiveType: Cesium.PrimitiveType.TRIANGLES,
            boundingSphere: bs
        });
        return geo;
    }
    return BasicGeometry;
});
define('Core/PlaneBufferGeometry',[
    'Core/BasicGeometry'
], function (
    BasicGeometry
    ) {

    /**
    *
    *@param {Number}width
    *@param {Number}height
    *@param {Number}widthSegments
    *@param {Number}heightSegments
    *@constructor
    *@memberof Cesium
    */
    function PlaneBufferGeometry(width, height, widthSegments, heightSegments) {
        this.width = width;
        this.height = height;
        this.widthSegments = widthSegments;
        this.heightSegments = heightSegments;

    }

    /**
    *
    *@param {}
    */
    PlaneBufferGeometry.createGeometry = function (planeBufferGeometry) {

        var width = planeBufferGeometry.width,
            height = planeBufferGeometry.height,
            widthSegments = planeBufferGeometry.widthSegments,
            heightSegments = planeBufferGeometry.heightSegments;


        width = width || 1;
        height = height || 1;

        var width_half = width / 2;
        var height_half = height / 2;

        var gridX = Math.floor(widthSegments) || 1;
        var gridY = Math.floor(heightSegments) || 1;

        var gridX1 = gridX + 1;
        var gridY1 = gridY + 1;

        var segment_width = width / gridX;
        var segment_height = height / gridY;

        var ix, iy;

        // buffers

        var indices = [];
        var vertices = [];
        var normals = [];
        var uvs = [];

        // generate vertices, normals and uvs

        for (iy = 0; iy < gridY1; iy++) {

            var y = iy * segment_height - height_half;

            for (ix = 0; ix < gridX1; ix++) {

                var x = ix * segment_width - width_half;

                vertices.push(x, -y, 0);

                normals.push(0, 0, 1);

                uvs.push(ix / gridX);
                uvs.push(1 - (iy / gridY));

            }

        }

        // indices

        for (iy = 0; iy < gridY; iy++) {

            for (ix = 0; ix < gridX; ix++) {

                var a = ix + gridX1 * iy;
                var b = ix + gridX1 * (iy + 1);
                var c = (ix + 1) + gridX1 * (iy + 1);
                var d = (ix + 1) + gridX1 * iy;

                // faces

                indices.push(a, b, d);
                indices.push(b, c, d);

            }

        }

        var geom= BasicGeometry.createGeometry({
            positions: new Float32Array(vertices),
            normals: new Float32Array(normals),
            uvs: new Float32Array(uvs),
            indices: new Int32Array(indices)
        })

         return geom;
    }

    return PlaneBufferGeometry;
});
define('Main',[
    'Core/RendererUtils',
    'Core/Mesh',
    'Core/MeshMaterial',
    'Core/Shaders/ShaderChunk',
    'Core/MeshVisualizer',
    'Core/FramebufferTexture',
    'Core/GeometryUtils',
    'Core/LOD',
    'Core/PlaneGeometry',
    'Core/Rotation',
    'Core/ReferenceMesh',
    'Core/BasicMeshMaterial',
    'Core/BasicGeometry',
    'Core/Shaders/ShaderLib',
    'Core/PlaneBufferGeometry',
    'Util/CSG',
    'Core/MeshPhongMaterial',
    'Core/MaterialUtils',
    'Core/ShaderUtils'
], function (
    RendererUtils,
    Mesh,
    MeshMaterial,
    ShaderChunk,
    MeshVisualizer,
    FramebufferTexture,
    GeometryUtils,
    LOD,
    PlaneGeometry,
    Rotation,
    ReferenceMesh,
    BasicMeshMaterial,
    BasicGeometry,
    ShaderLib,
    PlaneBufferGeometry,
    CSG,
    MeshPhongMaterial,
    MaterialUtils,
    ShaderUtils
  ) {
    if (typeof Cesium==='undefined') {
        Cesium = {};
    }
    Cesium.RendererUtils = RendererUtils;
    Cesium.Mesh = Mesh;
    Cesium.MeshMaterial = MeshMaterial;
    Cesium.ShaderChunk = ShaderChunk;
    Cesium.ShaderLib = ShaderLib;
    Cesium.MeshVisualizer = MeshVisualizer;
    Cesium.FramebufferTexture = FramebufferTexture;
    Cesium.GeometryUtils = GeometryUtils;
    Cesium.LOD = LOD;
    Cesium.PlaneGeometry = PlaneGeometry;
    Cesium.Rotation = Rotation;
    Cesium.ReferenceMesh = ReferenceMesh;
    Cesium.BasicMeshMaterial = BasicMeshMaterial;
    Cesium.BasicGeometry = BasicGeometry;
    Cesium.PlaneBufferGeometry = PlaneBufferGeometry;
    Cesium.CSG = CSG;
    Cesium.MeshPhongMaterial = MeshPhongMaterial;
    Cesium.MaterialUtils = MaterialUtils;
    Cesium.ShaderUtils = ShaderUtils;
    return Cesium;
});
    require([
                'Main'
    ], function (
                Cesium) {
        'use strict';
        /*global self*/
        var scope = typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {};

        scope.Cesium = Cesium;
        if (scope.onLoad) {
            scope.onLoad(Cesium)
        }
    }, undefined, true);

})();