+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/solar/js/CelestialBody.js b/solar/js/CelestialBody.js
new file mode 100644
index 0000000..8b2ed1a
--- /dev/null
+++ b/solar/js/CelestialBody.js
@@ -0,0 +1,407 @@
+// Celestial body constructor
+var CelestialBody = function (obj) {
+ // Meta
+ this.name = "";
+ // If the planet is the sun
+ this.star = false;
+ // Object shape info
+ this.spherical = true;
+ this.oblateness = 0.;
+ this.radius = 1.;
+ this.isComet = false;
+ this.particleSystem = null;
+ // Parent/moon objects
+ this.parent = null;
+ this.children = [];
+ // TODO: Model info, to be implemented
+ // Orbit parameters
+ // 周期（恒星）、半长轴、离心率、倾角、升交点黄经、平近点角 (历时原点假设轨道是圆形时的黄经偏移)
+
+ this.position = {
+ x: 0, y: 0, z: 0,
+ };
+
+ this.obj = {
+ path: null, objPath: null, mtlPath: null,
+ scale: 1., angle: 0., x: 0., y: 0., z: 0.
+ };
+
+ this.orbit = {
+ period: 1., semiMajorAxis: 1., eccentricity: 0.,
+ inclination: 0., ascendingNode: 0., meanLongitude: 0.
+ };
+ // Rotation parameters
+ // 周期（恒星）、倾角（黄赤夹角）、子午角（自转轴所在的与黄道垂直的平面，即子午面，与xOy平面的夹角）、历时原点角度偏移
+ // 注：这里我们使用xOz平面作为黄道面
+ this.rotation = {
+ period: 1., inclination: 1.,
+ meridianAngle: 0., offset: 0.
+ };
+ // 远景时显示光芒的参数设定
+ // albedo 为反照率
+ // 下面给出一个该把这个光点画多亮的粗略估计（只是用来看的，不是很严谨）
+ // x > R/k: (2 -
/(|c|*|p|)) * R^2 * a * log(k*x0/R) / log(k*x/R)
+ // else: 0
+ // 其中，a是反照率，记号<,>表示内积，|.|是二范数，c是摄像机坐标，p是天体坐标
+ // R 是天体半径，x 是距天体的距离，即|c - p|，k 是一个系数
+ this.albedo = 1.;
+ this.shineColor = 0xffffff;
+ // Material settings
+ this.material = {
+ // "phong", "lambert", "basic"
+ type: "phong",
+ diffuse: {map: null, color: 0xffffff},
+ specular: {map: null, color: 0xffffff, shininess: 25},
+ night: {map: null},
+ bump: {map: null, height: 10}
+ };
+ // Planet ring definitions
+ this.ring = {
+ map: null,
+ lower: 2000, higher: 6000,
+ color: 0xffffff, specularColor: 0xffffff, specularPower: 5
+ };
+ // halo effect
+ this.halo = {
+ color: null,
+ radius: 1.
+ };
+ this.atmosphere = {
+ cloud: {
+ map: null, height: 1, speed: 20
+ },
+ // By wave length
+ scattering: false,
+ atmosphereColor: new THREE.Vector3(0.5, 0.7, 0.8),
+ sunsetColor: new THREE.Vector3(0.8, 0.7, 0.6),
+ atmosphereStrength: 1.0,
+ sunsetStrength: 1.0
+ };
+
+ mergeRecursive(this, obj);
+};
+
+function mergeRecursive(obj1, obj2) {
+ for (var p in obj2) {
+ try {
+ //Property in destination object set; update its value.
+ if (obj2[p].constructor == Object) {
+ obj1[p] = mergeRecursive(obj1[p], obj2[p]);
+ } else {
+ obj1[p] = obj2[p];
+ }
+ } catch (e) {
+ //Property in destination object not set; create it and set its value.
+ obj1[p] = obj2[p];
+ }
+ }
+ return obj1;
+}
+
+// lens flare texture
+CelestialBody.prototype.flareTexture = textureLoader.load("res/effects/flare.jpg");
+
+// IMPORTANT: This function of the prototype generate the object and put it on
+// the scene. This is the most most important part in drawing the object.
+CelestialBody.prototype.generateObjectsOnScene = function (argScene) {
+ var that = this;
+ // if(this.spherical)
+ if (!this.spherical) {
+ if (this.isComet) {
+ this.cometPivot = new THREE.Group();
+ this.objectGroup = new THREE.Group();
+ this.particleSystem = new THREE.GPUParticleSystem({
+ maxParticles: 150000
+ });
+ this.objectGroup.add(this.particleSystem);
+ argScene.add(this.objectGroup);
+ } else {
+ this.objectGroup = new THREE.Group();
+ var onProgress = function (xhr) {
+ if (xhr.lengthComputable) {
+ var percentComplete = xhr.loaded / xhr.total * 100;
+ }
+ };
+ var onError = function (xhr) {
+ };
+ if (that.obj.mtlPath != null) {
+ mtlLoader.setPath(that.obj.path);
+ mtlLoader.load(that.obj.mtlPath, function (materials) {
+ materials.preload();
+ objLoader.setMaterials(materials);
+ objLoader.setPath(that.obj.path);
+ objLoader.load(that.obj.objPath, function (object) {
+ that.objectGroup.add(object);
+ var scale = that.obj.scale;
+ object.rotateY(that.obj.angle / 180.0 * Math.PI);
+ object.scale.set(scale, scale, scale);
+ object.translateX(that.obj.x);
+ object.translateY(that.obj.y);
+ object.translateZ(that.obj.z);
+ }, onProgress, onError);
+ });
+ } else {
+ objLoader.setPath(that.obj.path);
+ objLoader.load(that.obj.objPath, function (object) {
+ object.traverse(function (child) {
+ var material = new THREE.MeshLambertMaterial();
+ if (child instanceof THREE.Mesh) {
+ child.material = material;
+ }
+ });
+ that.objectGroup.add(object);
+ object.rotateY(that.obj.angle / 180.0 * Math.PI);
+ var scale = that.obj.scale;
+ object.scale.set(scale, scale, scale);
+ object.translateX(that.obj.x);
+ object.translateY(that.obj.y);
+ object.translateZ(that.obj.z);
+ }, onProgress, onError);
+ }
+ argScene.add(this.objectGroup);
+ }
+ } else {
+ this.bodySphereGeometry = new THREE.SphereGeometry(this.radius, 64, 64);
+ // else if(!this.spherical) blablabla...
+ // The base body sphere material
+ var sphereMaterial = this.bodySphereMaterial = null;
+ switch (this.material.type) {
+ case "basic":
+ sphereMaterial = this.bodySphereMaterial
+ = new THREE.MeshBasicMaterial({
+ color: new THREE.Color(this.material.diffuse.color)
+ });
+ if (this.material.diffuse.map !== null) {
+ sphereMaterial.map = textureLoader.load(this.material.diffuse.map);
+ }
+ break;
+ case "lambert":
+ sphereMaterial = this.bodySphereMaterial
+ = new THREE.MeshPhongMaterial({
+ color: new THREE.Color(this.material.diffuse.color),
+ specular: new THREE.Color(0x000000),
+ shininess: 0,
+ bumpScale: this.material.bump.height
+ });
+ if (this.material.diffuse.map !== null) {
+ sphereMaterial.map = textureLoader.load(this.material.diffuse.map);
+ }
+ break;
+ case "phong":
+ default:
+ sphereMaterial = this.bodySphereMaterial
+ = new THREE.MeshPhongMaterial({
+ color: new THREE.Color(this.material.diffuse.color),
+ specular: new THREE.Color(this.material.specular.color),
+ shininess: this.material.specular.shininess,
+ bumpScale: this.material.bump.height
+ });
+ if (this.material.diffuse.map !== null) {
+ sphereMaterial.map = textureLoader.load(this.material.diffuse.map);
+ }
+ if (this.material.specular.map !== null) {
+ sphereMaterial.specularMap = textureLoader.load(this.material.specular.map);
+ }
+ if (this.material.bump.map !== null) {
+ sphereMaterial.bumpMap = textureLoader.load(this.material.bump.map);
+ }
+ break;
+ }
+ this.objectGroup = new THREE.Group();
+ // Add the main body part
+ textureLoader.load(this.material.diffuse.map, function (texture) {
+ this.bodySphereMaterial = new THREE.MeshPhongMaterial({map: texture});
+ });
+ this.bodySphereMesh = new THREE.Mesh(this.bodySphereGeometry, this.bodySphereMaterial);
+ this.bodySphereMesh.scale.set(1, 1 - this.oblateness, 1);
+
+ // Add lens flare
+ this.lensFlare = null;
+ if (this.star) {
+ this.lensFlare =
+ new THREE.LensFlare(this.flareTexture, 200,
+ 0, THREE.AdditiveBlending, new THREE.Color(this.shineColor));
+ this.lensFlare.position.set(this.getX(), this.getY(), this.getZ());
+
+ var that = this;
+ this.lensFlare.customUpdateCallback = function () {
+ var cameraDistance = Math.sqrt(
+ (trackCamera[params.Camera].getX() - that.getX())
+ * (trackCamera[params.Camera].getX() - that.getX()),
+ (trackCamera[params.Camera].getY() - that.getY())
+ * (trackCamera[params.Camera].getY() - that.getY()),
+ (trackCamera[params.Camera].getZ() - that.getZ())
+ * (trackCamera[params.Camera].getZ() - that.getZ()));
+ this.transparent = 0.3;
+ if (cameraDistance < 6000) {
+ that.bodySphereMaterial.depthTest = true;
+ that.haloMaterial.depthTest = true;
+ that.cloudMaterial.depthTest = true;
+ }
+ else {
+ that.bodySphereMaterial.depthTest = false;
+ that.haloMaterial.depthTest = false;
+ }
+ this.updateLensFlares();
+ };
+ }
+
+ // Add night
+ this.nightMaterial = null;
+ this.nightSphereMesh = null;
+ if (this.material.night.map !== null) {
+ this.nightMaterial = new THREE.ShaderMaterial({
+ uniforms: {
+ nightTexture: {value: textureLoader.load(this.material.night.map)}
+ },
+ vertexShader: generalVS,
+ fragmentShader: nightFS,
+ transparent: true,
+ blending: THREE.CustomBlending,
+ blendEquation: THREE.AddEquation
+ });
+ this.nightSphereMesh = new THREE.Mesh(this.bodySphereGeometry, this.nightMaterial);
+ this.objectGroup.add(this.nightSphereMesh);
+ }
+
+ // Add clouds
+ this.cloudGeometry = null;
+ this.cloudMaterial = null;
+ this.cloudMesh = null;
+ if (this.atmosphere.cloud.map !== null) {
+ this.cloudGeometry = new THREE.SphereGeometry(this.radius + this.atmosphere.cloud.height, 64, 64);
+ if (!this.star) {
+ this.cloudMaterial = new THREE.MeshLambertMaterial({
+ map: textureLoader.load(this.atmosphere.cloud.map),
+ transparent: true
+ });
+ } else {
+ this.cloudMaterial = new THREE.MeshBasicMaterial({
+ map: textureLoader.load(this.atmosphere.cloud.map),
+ transparent: true
+ });
+ }
+ this.cloudMesh = new THREE.Mesh(this.cloudGeometry, this.cloudMaterial);
+ }
+
+ // Add atmosphere
+ this.atmosphereGeometry = null;
+ this.atmosphereMaterial = null;
+ this.atmosphereMesh = null;
+ if (this.atmosphere.scattering) {
+ this.atmosphereGeometry = new THREE.SphereGeometry(this.radius * 1.015, 64, 64);
+ this.atmosphereMaterial = new THREE.ShaderMaterial({
+ uniforms: {
+ atmosphereColor: {value: this.atmosphere.atmosphereColor},
+ sunsetColor: {value: this.atmosphere.sunsetColor},
+ atmosphereStrength: {value: this.atmosphere.atmosphereStrength},
+ sunsetStrength: {value: this.atmosphere.sunsetStrength}
+ },
+ vertexShader: atmosphereVS,
+ fragmentShader: atmosphereFS,
+ transparent: true,
+ blending: THREE.CustomBlending,
+ blendEquation: THREE.AddEquation
+ });
+ this.atmosphereMesh = new THREE.Mesh(this.atmosphereGeometry, this.atmosphereMaterial);
+ this.objectGroup.add(this.atmosphereMesh);
+ }
+
+ this.haloGeometry = null;
+ this.haloMaterial = null;
+ this.haloMesh = null;
+ if (this.halo.color != null) {
+ this.haloGeometry = new THREE.SphereGeometry(this.halo.radius, 64, 64);
+ this.haloMaterial = new THREE.ShaderMaterial({
+ uniforms: {
+ color: {value: this.halo.color}
+ },
+ vertexShader: haloVS,
+ fragmentShader: haloFS,
+ transparent: true,
+ blending: THREE.CustomBlending,
+ blendEquation: THREE.AddEquation
+ });
+ this.haloMesh = new THREE.Mesh(this.haloGeometry, this.haloMaterial);
+ this.objectGroup.add(this.haloMesh);
+ }
+
+ // Add rings
+ // Add clouds
+ this.ringGeometry = null;
+ this.ringMaterial = null;
+ this.ringMeshPositive = null;
+ this.ringMeshNegative = null;
+ this.ringTexture = null;
+ if (this.ring.map !== null) {
+ this.ringTexture = textureLoader.load(this.ring.map);
+ this.ringTexture.rotation = Math.PI / 2;
+ this.ringGeometry = new THREE.CylinderGeometry(this.radius + this.ring.lower, this.radius + this.ring.higher, 0, 100, 100, true);
+ this.ringMaterial = new THREE.MeshPhongMaterial({
+ map: this.ringTexture, transparent: true,
+ emissive: new THREE.Color(0x222222)
+ });
+ this.ringMeshPositive = new THREE.Mesh(this.ringGeometry, this.ringMaterial);
+ this.ringGeometry = new THREE.CylinderGeometry(this.radius + this.ring.higher, this.radius + this.ring.lower, 0, 100, 100, true);
+ this.ringMeshNegative = new THREE.Mesh(this.ringGeometry, this.ringMaterial);
+ // if(this.name === "Saturn") {
+ // this.ringMeshPositive.castShadow = true;
+ // this.ringMeshPositive.receiveShadow = true;
+ // this.ringMeshNegative.castShadow = true;
+ // this.ringMeshNegative.receiveShadow = true;
+ // this.bodySphereMesh.castShadow = true;
+ // this.bodySphereMesh.receiveShadow = true;
+ // }
+ }
+
+ // Add meshes to the object group
+ if (this.lensFlare != null) this.objectGroup.add(this.lensFlare);
+ this.objectGroup.add(this.bodySphereMesh);
+
+ if (this.ringMeshPositive !== null) {
+ this.objectGroup.add(this.ringMeshPositive);
+ this.objectGroup.add(this.ringMeshNegative);
+ }
+ if (this.cloudMesh !== null) {
+ this.objectGroup.add(this.cloudMesh);
+ }
+ // simple inclination
+ this.objectGroup.rotateZ(this.rotation.inclination / 180.0 * Math.PI);
+ argScene.add(this.objectGroup);
+ }
+};
+
+
+CelestialBody.prototype.updateClouds = function (time) {
+ if (this.cloudGeometry !== null) {
+ this.cloudGeometry.rotateY(this.atmosphere.cloud.speed / 180.0 * Math.PI);
+ }
+}
+
+CelestialBody.prototype.update = function (time) {
+ if (this.objectGroup !== undefined || this.isComet) {
+ this.updateOrbitAndRotation(time);
+ if (this.spherical && !this.isComet)
+ this.updateClouds(time);
+ }
+};
+
+CelestialBody.prototype.getX = function () {
+ if (this.objectGroup == null || this.objectGroup.position == null) return 0;
+ return this.objectGroup.position.getComponent(0);
+};
+
+CelestialBody.prototype.getY = function () {
+ if (this.objectGroup == null || this.objectGroup.position == null) return 0;
+ return this.objectGroup.position.getComponent(1);
+};
+
+CelestialBody.prototype.getZ = function () {
+ if (this.objectGroup == null || this.objectGroup.position == null) return 0;
+ return this.objectGroup.position.getComponent(2);
+};
+
+CelestialBody.prototype.getRadius = function () {
+ if (this.objectGroup == null || this.objectGroup.position == null) return 0;
+ return this.radius;
+};
\ No newline at end of file
diff --git a/solar/js/Detector.js b/solar/js/Detector.js
new file mode 100644
index 0000000..17b7207
--- /dev/null
+++ b/solar/js/Detector.js
@@ -0,0 +1,79 @@
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mr.doob / http://mrdoob.com/
+ */
+
+var Detector = {
+
+ canvas: !!window.CanvasRenderingContext2D,
+ webgl: (function () {
+
+ try {
+
+ var canvas = document.createElement('canvas');
+ return !!( window.WebGLRenderingContext && ( canvas.getContext('webgl') || canvas.getContext('experimental-webgl') ) );
+
+ } catch (e) {
+
+ return false;
+
+ }
+
+ })(),
+ workers: !!window.Worker,
+ fileapi: window.File && window.FileReader && window.FileList && window.Blob,
+
+ getWebGLErrorMessage: function () {
+
+ var element = document.createElement('div');
+ element.id = 'webgl-error-message';
+ element.style.fontFamily = 'monospace';
+ element.style.fontSize = '13px';
+ element.style.fontWeight = 'normal';
+ element.style.textAlign = 'center';
+ element.style.background = '#fff';
+ element.style.color = '#000';
+ element.style.padding = '1.5em';
+ element.style.width = '400px';
+ element.style.margin = '5em auto 0';
+
+ if (!this.webgl) {
+
+ element.innerHTML = window.WebGLRenderingContext ? [
+ 'Your graphics card does not seem to support WebGL.
',
+ 'Find out how to get it here.'
+ ].join('\n') : [
+ 'Your browser does not seem to support WebGL.
',
+ 'Find out how to get it here.'
+ ].join('\n');
+
+ }
+
+ return element;
+
+ },
+
+ addGetWebGLMessage: function (parameters) {
+
+ var parent, id, element;
+
+ parameters = parameters || {};
+
+ parent = parameters.parent !== undefined ? parameters.parent : document.body;
+ id = parameters.id !== undefined ? parameters.id : 'oldie';
+
+ element = Detector.getWebGLErrorMessage();
+ element.id = id;
+
+ parent.appendChild(element);
+
+ }
+
+};
+
+// browserify support
+if (typeof module === 'object') {
+
+ module.exports = Detector;
+
+}
diff --git a/solar/js/animation.js b/solar/js/animation.js
new file mode 100644
index 0000000..00c8189
--- /dev/null
+++ b/solar/js/animation.js
@@ -0,0 +1,36 @@
+function remain(objKey) {
+ if (celestialBodies[objKey].parent == null)
+ return true;
+ if ((calculateParams[celestialBodies[objKey].parent.name] && celestialBodies[objKey].parent.name != "Sun") ||
+ calculateParams[objKey])
+ return true;
+ return false;
+}
+
+function render() {
+ for (var objKey in celestialBodies) {
+ if (firstflag || remain(objKey)) {
+ celestialBodies[objKey].update(globalTime.getRelative());
+ if (orbitParams[objKey]) {
+ scene.add(orbitDraw[objKey]);
+ } else {
+ scene.remove(orbitDraw[objKey]);
+ }
+ }
+ }
+ if (firstflag) {
+ $(function () {
+ setTimeout(function () {
+ $("#prompt").fadeOut(500);
+ container.appendChild(stats.domElement);
+ container.appendChild(renderer.domElement);
+ gui.open();
+ }, 2000);
+ });
+ }
+ firstflag = false;
+ if (needSet) {
+ renderCamera.setCamera();
+ }
+ renderer.render(scene, renderCamera.camera);
+}
\ No newline at end of file
diff --git a/solar/js/cameraParameters.js b/solar/js/cameraParameters.js
new file mode 100644
index 0000000..2a42612
--- /dev/null
+++ b/solar/js/cameraParameters.js
@@ -0,0 +1,46 @@
+var cameraParameters = function (distance, safeDistance, body) {
+ this.theta = 0.2;
+ this.phi = 0.3;
+ this.distance = distance;
+ this.safeDistance = safeDistance;
+ this.safeFar = 1e6;
+ this.body = body;
+ this.camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 0.4, 1e7);
+};
+
+cameraParameters.prototype.getDistance = function () {
+ return this.distance;
+};
+cameraParameters.prototype.getCenterX = function () {
+ if (this.body == "Comet")
+ return celestialBodies["Comet"].cometPivot.position.getComponent(0);
+ else
+ return celestialBodies[this.body].getX();
+};
+cameraParameters.prototype.getCenterY = function () {
+ if (this.body == "Comet")
+ return celestialBodies["Comet"].cometPivot.position.getComponent(1);
+ else
+ return celestialBodies[this.body].getY();
+};
+cameraParameters.prototype.getCenterZ = function () {
+ if (this.body == "Comet")
+ return celestialBodies["Comet"].cometPivot.position.getComponent(2);
+ else
+ return celestialBodies[this.body].getZ();
+};
+cameraParameters.prototype.getX = function () {
+ return this.getCenterX() - (celestialBodies[this.body].getRadius() + this.distance) * Math.cos(this.theta) * Math.cos(this.phi);
+};
+cameraParameters.prototype.getZ = function () {
+ return this.getCenterZ() - (celestialBodies[this.body].getRadius() + this.distance) * Math.sin(this.theta) * Math.cos(this.phi);
+};
+cameraParameters.prototype.getY = function () {
+ return this.getCenterY() - (celestialBodies[this.body].getRadius() + this.distance) * Math.sin(this.phi);
+};
+cameraParameters.prototype.setCamera = function () {
+ this.camera.position.x = this.getX();
+ this.camera.position.y = this.getY();
+ this.camera.position.z = this.getZ();
+ this.camera.lookAt(this.getCenterX(), this.getCenterY(), this.getCenterZ());
+};
\ No newline at end of file
diff --git a/solar/js/control.js b/solar/js/control.js
new file mode 100644
index 0000000..45adfcd
--- /dev/null
+++ b/solar/js/control.js
@@ -0,0 +1,181 @@
+var windowHalfX = window.innerWidth / 2;
+var windowHalfY = window.innerHeight / 2;
+
+var mouseStatus = {
+ x: 0, y: 0,
+ leftDown: false, centerDown: false, rightDown: false
+};
+
+function onWindowMouseMove(event) {
+ // Keep the value in 0 -- 2 PI
+ var body = params.Camera;
+ if (mouseStatus.leftDown) {
+ trackCamera[body].theta = trackCamera[body].theta % (2 * Math.PI);
+ trackCamera[body].phi = trackCamera[body].phi % (0.5 * Math.PI);
+
+ trackCamera[body].theta += (event.clientX - windowHalfX - mouseStatus.x) * 0.01;
+
+ if (trackCamera[body].phi - (event.clientY - windowHalfY - mouseStatus.y) * 0.01 >= -0.5 * Math.PI &&
+ trackCamera[body].phi - (event.clientY - windowHalfY - mouseStatus.y) * 0.01 <= 0.5 * Math.PI)
+ trackCamera[body].phi -= (event.clientY - windowHalfY - mouseStatus.y) * 0.01;
+ }
+ mouseStatus.x = event.clientX - windowHalfX;
+ mouseStatus.y = event.clientY - windowHalfY;
+}
+
+function onWindowMouseDown(event) {
+ switch (event.which) {
+ case 1:
+ mouseStatus.leftDown = true;
+ break;
+ case 2:
+ mouseStatus.centerDown = true;
+ break;
+ case 3:
+ default:
+ mouseStatus.rightDown = true;
+ break;
+ }
+}
+
+function onWindowMouseUp(event) {
+ switch (event.which) {
+ case 1:
+ mouseStatus.leftDown = false;
+ break;
+ case 2:
+ mouseStatus.centerDown = false;
+ break;
+ case 3:
+ default:
+ mouseStatus.rightDown = false;
+ break;
+ }
+}
+
+function onMouseWheelChange(event) {
+ var body = params.Camera;
+ var delta = Math.max(-1, Math.min(1, (event.wheelDelta || -event.detail)));
+ var newDistance = trackCamera[body].distance - 0.05 * trackCamera[body].distance * delta;
+
+ if (newDistance <= trackCamera[body].safeDistance) {
+ newDistance = trackCamera[body].safeDistance;
+ } else if (newDistance >= trackCamera[body].safeFar) {
+ newDistance = trackCamera[body].safeFar;
+ }
+ trackCamera[body].distance = newDistance;
+}
+
+var posSrc = { pos: 0.0 };
+var oX, oY, oZ, dX, dY, dZ, oTheta, dTheta, oPhi, dPhi, oDistance, dDistance, oSafeDis, dSafeDis;
+var oCX, oCY, oCZ, dCX, dCY, dCZ;
+tween = new TWEEN.Tween(posSrc)
+ .to({ pos: 1.0 }, 4000)
+ .easing(TWEEN.Easing.Quartic.InOut)
+ .onStart(function () {
+ globalTimeFlag = false;
+ })
+ .onUpdate(function () {
+ var pos = posSrc.pos;
+ switchCamera.camera.position.set(oX + dX * pos, oY + dY * pos, oZ + dZ * pos);
+ switchCamera.theta = oTheta + dTheta * pos;
+ switchCamera.phi = oPhi + dPhi * pos;
+ switchCamera.distance = oDistance + dDistance * pos;
+ switchCamera.safeDistance = oSafeDis + dSafeDis * pos;
+ switchCamera.camera.lookAt(oCX + dCX * pos, oCY + dCY * pos, oCZ + dCZ * pos);
+ })
+ .onComplete(function () {
+ // Need switching to roaming mode
+ if (goRoaming) {
+ calculateParams[curBody] = saveCur;
+ calculateParams["Earth"] = saveNext;
+ renderCamera = roamingCamera;
+ cameraControl = new THREE.FirstPersonControls(roamingCamera.camera);
+ cameraControl.lookSpeed = 0.1;
+ cameraControl.movementSpeed = 150;
+ cameraControl.noFly = true;
+ cameraControl.constrainVertical = true;
+ cameraControl.verticalMin = 1.0;
+ cameraControl.verticalMax = 2.0;
+ cameraControl.lon = -150;
+ cameraControl.lat = 120;
+ needSet = false;
+ roamingStatus = true;
+ goRoaming = false;
+ roamingCamera.camera.lookAt(0, 0, 0);
+ } else {
+ calculateParams[curBody] = saveCur;
+ calculateParams[nextBody] = saveNext;
+ switchCamera.body = nextBody;
+ curBody = nextBody;
+ needSet = true;
+ renderCamera = trackCamera[nextBody];
+ }
+ globalTimeFlag = true;
+ });
+
+function initTween() {
+ saveCur = calculateParams[curBody];
+ saveNext = calculateParams[nextBody];
+ calculateParams[curBody] = false;
+ calculateParams[nextBody] = false;
+ renderCamera = switchCamera;
+ posSrc.pos = 0.0;
+ needSet = false;
+}
+
+function setTween(cur, next) {
+ if (cur == null) {
+ oX = arguments[2];
+ oY = arguments[3];
+ oZ = arguments[4];
+ oTheta = 0.2;
+ oPhi = 0.3;
+ oDistance = 30;
+ oSafeDis = 30;
+ oCX = roamingCamera.camera.position.x;
+ oCY = roamingCamera.camera.position.y;
+ oCZ = roamingCamera.camera.position.z;
+ } else {
+ oX = trackCamera[cur].getX();
+ oY = trackCamera[cur].getY();
+ oZ = trackCamera[cur].getZ();
+ oTheta = trackCamera[cur].theta;
+ oPhi = trackCamera[cur].phi;
+ oDistance = trackCamera[cur].distance;
+ oSafeDis = trackCamera[cur].safeDistance;
+ oCX = trackCamera[cur].getCenterX();
+ oCY = trackCamera[cur].getCenterY();
+ oCZ = trackCamera[cur].getCenterZ();
+ }
+ if (next == null) {
+ dCX = dX = arguments[2] - oX;
+ dCY = dY = arguments[3] - oY;
+ dCZ = dZ = arguments[4] - oZ;
+ dTheta = 0.2 - oTheta;
+ dPhi = 0.3 - oPhi;
+ dDistance = 30 - oDistance;
+ dSafeDis = 30 - oSafeDis;
+ } else {
+ dX = trackCamera[next].getX() - oX;
+ dY = trackCamera[next].getY() - oY;
+ dZ = trackCamera[next].getZ() - oZ;
+ dCX = trackCamera[next].getCenterX() - oCX;
+ dCY = trackCamera[next].getCenterY() - oCY;
+ dCZ = trackCamera[next].getCenterZ() - oCZ;
+ dTheta = trackCamera[next].theta - oTheta;
+ dPhi = trackCamera[next].phi - oPhi;
+ dDistance = trackCamera[next].distance - oDistance;
+ dSafeDis = trackCamera[next].safeDistance - oSafeDis;
+ }
+}
+
+function cameraCopy(cameraDst, cameraSrc) {
+ cameraDst.theta = cameraSrc.theta;
+ cameraDst.phi = cameraSrc.phi;
+ cameraDst.distance = cameraSrc.distance;
+ cameraDst.safeDistance = cameraSrc.safeDistance;
+ cameraDst.body = cameraSrc.body;
+ cameraDst.setCamera();
+}
+
diff --git a/solar/js/data.js b/solar/js/data.js
new file mode 100644
index 0000000..b0a4bc9
--- /dev/null
+++ b/solar/js/data.js
@@ -0,0 +1,547 @@
+celestialBodies = {
+ Sun: new CelestialBody({
+ name: "Sun",
+ star: true,
+ parent: "Sun",
+ radius: 200.,
+ shineColor: 0xfff700,
+ orbit: {
+ semiMajorAxis: 0.
+ },
+ rotation: {
+ period: 2500,
+ inclination: 0,
+ },
+ material: {
+ type: "basic",
+ diffuse: {map: "res/sol/diffuse.png"}
+ },
+ atmosphere: {
+ cloud: {
+ map: "res/sol/overlay.png",
+ height: 1,
+ speed: 1
+ }
+ },
+ halo: {
+ color: new THREE.Color(0xfff700),
+ radius: 500.
+ }
+ }),
+ Mercury: new CelestialBody({
+ name: "Mercury",
+ radius: 3.8256,
+ parent: "Sun",
+ shineColor: 0x9999ff,
+ orbit: {
+ period: 1.204,
+ semiMajorAxis: 387.1,
+ eccentricity: 0.2056,
+ inclination: 7.0049
+ },
+ rotation: {
+ period: 1407.509405,
+ inclination: 28.55,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/mercury/diffuse.jpg"},
+ bump: {map: "res/mercury/bump.jpg", height: 0.}
+ }
+ }),
+ Venus: new CelestialBody({
+ name: "Venus",
+ radius: 9.488,
+ parent: "Sun",
+ shineColor: 0x9999ff,
+ orbit: {
+ period: 3.076,
+ semiMajorAxis: 723.3,
+ eccentricity: 0.0068,
+ inclination: 3.3947
+ },
+ rotation: {
+ period: 5832.443616,
+ inclination: 157.16,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/venus/diffuse.jpg"},
+ bump: {map: "res/venus/bump.jpg", height: 0.}
+ },
+ atmosphere: {
+ cloud: {
+ map: "res/venus/clouds.jpg",
+ height: 0.5,
+ speed: 0.02
+ }
+ }
+ }),
+ Earth: new CelestialBody({
+ name: "Earth",
+ radius: 10.,
+ parent: "Sun",
+ shineColor: 0x6666ff,
+ orbit: {
+ period: 5.,
+ semiMajorAxis: 1000.,
+ eccentricity: 0.0167,
+ inclination: 0.0001
+ },
+ rotation: {
+ period: 23.93447117,
+ inclination: -23.4392911,
+ meridianAngle: 280.147,
+ offset: 0.
+ },
+ material: {
+ type: "phong",
+ diffuse: {map: "res/earth/diffuse.jpg"},
+ specular: {map: "res/earth/spec.jpg", color: 0x243232, shininess: 25},
+ bump: {map: "res/earth/bump.jpg", height: 0.05},
+ night: {map: "res/earth/night.png"}
+ },
+ atmosphere: {
+ cloud: {
+ map: "res/earth/clouds.png",
+ height: 0.1,
+ speed: 0.02
+ },
+ scattering: true,
+ atmosphereColor: new THREE.Vector3(0.5, 0.7, 0.8),
+ sunsetColor: new THREE.Vector3(0.8, 0.7, 0.6),
+ atmosphereStrength: 1.5,
+ sunsetStrength: 1.0
+ }
+ }),
+ Comet: new CelestialBody({
+ name: "Comet",
+ parent: "Sun",
+ radius: 0,
+ spherical: false,
+ isComet: true,
+ orbit: {
+ period: 3.5,
+ semiMajorAxis: 3000.,
+ eccentricity: 0.5,
+ inclination: 10.,
+ },
+ }),
+ Ship: new CelestialBody({
+ name: "Ship",
+ parent: "Earth",
+ radius: 0.2,
+ spherical: false,
+ obj: {
+ path: "res/space/",
+ objPath: "tiangong.obj",
+ mtlPath: "tiangong.mtl",
+ angle: -30,
+ scale: 0.008,
+ },
+ orbit: {
+ period: 1.0,
+ semiMajorAxis: 15.,
+ inclination: 30,
+ },
+ rotation: {
+ period: 100.0,
+ inclination: 0,
+ },
+ }),
+ Astronaut: new CelestialBody({
+ name: "Astronaut",
+ parent: "Earth",
+ radius: 0.05,
+ spherical: false,
+ obj: {
+ path: "res/space/",
+ objPath: "man.obj",
+ mtlPath: null,
+ scale: 0.008,
+ angle: 235,
+ x: 0.04,
+ y: 0.02,
+ z: 0.01,
+ },
+ orbit: {
+ period: 1.0,
+ semiMajorAxis: 15.,
+ inclination: 30,
+ },
+ rotation: {
+ period: 100.0,
+ inclination: 0,
+ },
+ }),
+ Moon: new CelestialBody({
+ name: "Moon",
+ radius: 2.7243,
+ parent: "Earth",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 2.0749,
+ semiMajorAxis: 25.,
+ eccentricity: 0.0549,
+ inclination: 5.15
+ },
+ rotation: {
+ period: 655.2,
+ inclination: 23.4608,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/moon/diffuse.jpg"},
+ bump: {map: "res/moon/bump.jpg", height: 0.1}
+ }
+ }),
+ Mars: new CelestialBody({
+ name: "Mars",
+ radius: 5.3226,
+ parent: "Sun",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 9.4095,
+ semiMajorAxis: 1523.7,
+ eccentricity: 0.0934,
+ inclination: 1.8506
+ },
+ rotation: {
+ period: 24.622962156,
+ inclination: 37.11350,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/mars/diffuse.jpg"},
+ bump: {map: "res/mars/bump.jpg", height: 1.}
+ },
+ atmosphere: {
+ scattering: true,
+ atmosphereColor: new THREE.Vector3(0.9, 0.8, 0.6),
+ sunsetColor: new THREE.Vector3(0.4, 0.5, 0.7),
+ atmosphereStrength: 1.0,
+ sunsetStrength: 0.9
+ }
+ }),
+ Phobos: new CelestialBody({
+ name: "Phobos",
+ radius: 1,
+ parent: "Mars",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 1.5945,
+ semiMajorAxis: 20,
+ eccentricity: 0.0151,
+ inclination: 1.082
+ },
+ rotation: {
+ period: 100.,
+ inclination: 37.10,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/phobos/diffuse.jpg"},
+ bump: {map: "res/phobos/bump.jpg", height: 10.}
+ }
+ }),
+ Deimos: new CelestialBody({
+ name: "Deimos",
+ radius: 0.5,
+ parent: "Mars",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 6.3122,
+ semiMajorAxis: 30,
+ eccentricity: 0.00033,
+ inclination: 1.791
+ },
+ rotation: {
+ period: 150.,
+ inclination: 36.48,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/deimos/diffuse.jpg"},
+ bump: {map: "res/deimos/bump.jpg", height: 10.}
+ }
+ }),
+ Jupiter: new CelestialBody({
+ name: "Jupiter",
+ radius: 112.09,
+ parent: "Sun",
+ shineColor: 0x9999ff,
+ orbit: {
+ period: 59.3,
+ semiMajorAxis: 2000.,
+ eccentricity: 0.0484,
+ inclination: 1.3053
+ },
+ rotation: {
+ period: 238.23,
+ inclination: 2.22,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/jupiter/diffuse.jpg"},
+ },
+ atmosphere: {
+ cloud: {
+ map: "res/jupiter/clouds.png",
+ height: 0.3,
+ speed: 0.02
+ },
+ scattering: true,
+ atmosphereColor: new THREE.Vector3(1.0, 0.8, 0.7),
+ sunsetColor: new THREE.Vector3(0.7, 0.7, 0.8),
+ atmosphereStrength: 1.8,
+ sunsetStrength: 0.6
+ },
+ }),
+ Callisto: new CelestialBody({
+ name: "Callisto",
+ radius: 4.0,
+ parent: "Jupiter",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 2.49,
+ semiMajorAxis: 200.,
+ eccentricity: 0.0045045,
+ inclination: 0.384285,
+ },
+ rotation: {
+ period: 100.,
+ inclination: 25.51,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/callisto/diffuse.jpg"},
+ }
+ }),
+ Europa: new CelestialBody({
+ name: "Europa",
+ radius: 3.0,
+ parent: "Jupiter",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 17.76,
+ semiMajorAxis: 160.,
+ eccentricity: 0.0101,
+ inclination: 0.470,
+ },
+ rotation: {
+ period: 150.,
+ inclination: 25.49,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/europa/diffuse.jpg"},
+ }
+ }),
+ Io: new CelestialBody({
+ name: "Io",
+ radius: 3.0,
+ parent: "Jupiter",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 8.85,
+ semiMajorAxis: 100.,
+ eccentricity: 0.0041,
+ inclination: 0.040,
+ },
+ rotation: {
+ period: 100.,
+ inclination: 25.50,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/io/diffuse.png"},
+ }
+ }),
+ Saturn: new CelestialBody({
+ name: "Saturn",
+ radius: 94.49,
+ parent: "Sun",
+ shineColor: 0x9999ff,
+ orbit: {
+ period: 40.0,
+ semiMajorAxis: 2500.,
+ eccentricity: 0.0542,
+ inclination: 2.4845
+ },
+ rotation: {
+ period: 255.75,
+ inclination: 28.052,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/saturn/diffuse.png"},
+ bump: {map: "res/saturn/bump.png"},
+ },
+ atmosphere: {
+ cloud: {
+ map: "res/saturn/clouds.png",
+ height: 0.5,
+ speed: 0.05
+ },
+ scattering: true,
+ atmosphereColor: new THREE.Vector3(0.8, 0.7, 0.5),
+ sunsetColor: new THREE.Vector3(0.7, 0.7, 0.8),
+ atmosphereStrength: 1.5,
+ sunsetStrength: 0.8
+ },
+ ring: {
+ map: "res/saturn/ring.png",
+ lower: 5,
+ higher: 80,
+ }
+ }),
+ Dione: new CelestialBody({
+ name: "Dione",
+ radius: 5.0,
+ parent: "Saturn",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 3.0,
+ semiMajorAxis: 200.,
+ eccentricity: 0.05,
+ inclination: 0.0049,
+ },
+ rotation: {
+ period: 130.,
+ inclination: 22.9,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/dione/diffuse.jpg"},
+ }
+ }),
+ Titan: new CelestialBody({
+ name: "Titan",
+ radius: 6.0,
+ parent: "Saturn",
+ shineColor: 0xff9988,
+ orbit: {
+ period: 4.0,
+ semiMajorAxis: 150.,
+ eccentricity: 0.05,
+ inclination: 0.0049,
+ },
+ rotation: {
+ period: 120.,
+ inclination: 1.53,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/titan/diffuse.jpg"},
+ }
+ }),
+ Uranus: new CelestialBody({
+ name: "Uranus",
+ radius: 40.07,
+ parent: "Sun",
+ shineColor: 0x9999ff,
+ orbit: {
+ period: 420.069,
+ semiMajorAxis: 3000.,
+ eccentricity: 0.0472,
+ inclination: 0.7699
+ },
+ rotation: {
+ period: 413.76,
+ inclination: 97.722,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/uranus/diffuse.jpg"},
+ },
+ ring: {
+ map: "res/uranus/ring.png",
+ lower: 10,
+ higher: 20,
+ },
+ atmosphere: {
+ scattering: true,
+ atmosphereColor: new THREE.Vector3(0.5, 0.9, 0.7),
+ sunsetColor: new THREE.Vector3(0.7, 0.9, 0.8),
+ atmosphereStrength: 0.2,
+ sunsetStrength: 0.7
+ },
+ }),
+ Neptune: new CelestialBody({
+ name: "Neptune",
+ radius: 38.83,
+ parent: "Sun",
+ shineColor: 0x9999ff,
+ orbit: {
+ period: 823.965,
+ semiMajorAxis: 3500.,
+ eccentricity: 0.0097,
+ inclination: 1.7692
+ },
+ rotation: {
+ period: 386.64,
+ inclination: 28.03,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/neptune/diffuse.jpg"},
+ },
+ ring: {
+ map: "res/neptune/ring.png",
+ lower: 10,
+ higher: 20,
+ }
+ }),
+ Pluto: new CelestialBody({
+ name: "Pluto",
+ radius: 15.,
+ parent: "Sun",
+ shineColor: 0x9999ff,
+ orbit: {
+ period: 32.0,
+ semiMajorAxis: 4000.,
+ eccentricity: 0.2482,
+ inclination: 17.1449
+ },
+ rotation: {
+ period: 153.292944,
+ inclination: 115.60,
+ meridianAngle: 0.,
+ offset: 0.
+ },
+ material: {
+ type: "lambert",
+ diffuse: {map: "res/pluto/diffuse.jpg"},
+ },
+ }),
+}
diff --git a/solar/js/index.js b/solar/js/index.js
new file mode 100644
index 0000000..622a4ba
--- /dev/null
+++ b/solar/js/index.js
@@ -0,0 +1,258 @@
+(function ($) {
+
+ // Creating a number of jQuery plugins that you can use to
+ // initialize and control the progress meters.
+
+ $.fn.progressInitialize = function () {
+
+ // This function creates the necessary markup for the progress meter
+ // and sets up a few event listeners.
+
+
+ // Loop through all the buttons:
+
+ return this.each(function () {
+
+ var button = $(this),
+ progress = 0;
+
+ // Extract the data attributes into the options object.
+ // If they are missing, they will receive default values.
+
+ var options = $.extend({
+ type: 'background-horizontal',
+ loading: 'Loading',
+ finished: 'Done'
+ }, button.data());
+
+ // Add the data attributes if they are missing from the element.
+ // They are used by our CSS code to show the messages
+ button.attr({'data-loading': options.loading, 'data-finished': options.finished});
+
+ // Add the needed markup for the progress bar to the button
+ var bar = $('').appendTo(button);
+
+
+ // The progress event tells the button to update the progress bar
+ button.on('progress', function (e, val, absolute, finish) {
+
+ if (!button.hasClass('in-progress')) {
+
+ // This is the first progress event for the button (or the
+ // first after it has finished in a previous run). Re-initialize
+ // the progress and remove some classes that may be left.
+
+ bar.show();
+ progress = 0;
+ button.removeClass('finished').addClass('in-progress')
+ }
+
+ // val, absolute and finish are event data passed by the progressIncrement
+ // and progressSet methods that you can see near the end of this file.
+
+ if (absolute) {
+ progress = val;
+ }
+ else {
+ progress += val;
+ }
+
+ if (progress >= 100) {
+ progress = 100;
+ }
+
+ // if(finish){
+ //
+ // button.removeClass('in-progress').addClass('finished');
+ //
+ // bar.delay(500).fadeOut(function(){
+ //
+ // // Trigger the custom progress-finish event
+ // button.trigger('progress-finish');
+ // setProgress(0);
+ // });
+ //
+ // }
+
+ setProgress(progress);
+ });
+
+ function setProgress(percentage) {
+ bar.filter('.background-horizontal,.background-bar').width(percentage + '%');
+ bar.filter('.background-vertical').height(percentage + '%');
+ }
+
+ });
+
+ };
+
+ // progressStart simulates activity on the progress meter. Call it first,
+ // if the progress is going to take a long time to finish.
+
+ $.fn.progressStart = function () {
+
+ var button = this.first(),
+ last_progress = new Date().getTime();
+
+ if (button.hasClass('in-progress')) {
+ // Don't start it a second time!
+ return this;
+ }
+
+ button.on('progress', function () {
+ last_progress = new Date().getTime();
+ });
+
+ // Every half a second check whether the progress
+ // has been incremented in the last two seconds
+
+ var interval = window.setInterval(function () {
+
+ if (new Date().getTime() > 2000 + last_progress) {
+
+ // There has been no activity for two seconds. Increment the progress
+ // bar a little bit to show that something is happening
+
+ button.progressIncrement(5);
+ }
+
+ }, 500);
+
+ button.on('progress-finish', function () {
+ window.clearInterval(interval);
+ });
+
+ return button.progressIncrement(10);
+ };
+
+ $.fn.progressFinish = function () {
+ return this.first().progressSet(100);
+ };
+
+ $.fn.progressIncrement = function (val) {
+
+ val = val || 10;
+
+ var button = this.first();
+
+ button.trigger('progress', [val])
+
+ return this;
+ };
+
+ $.fn.progressSet = function (val) {
+ val = val || 10;
+
+ var finish = false;
+ if (val >= 100) {
+ finish = true;
+ }
+
+ return this.first().trigger('progress', [val, true, finish]);
+ };
+
+ // This function creates a progress meter that
+ // finishes in a specified amount of time.
+
+ $.fn.progressTimed = function (seconds, cb) {
+
+ var button = this.first(),
+ bar = button.find('.tz-bar');
+
+ if (button.is('.in-progress')) {
+ return this;
+ }
+
+ // Set a transition declaration for the duration of the meter.
+ // CSS will do the job of animating the progress bar for us.
+
+ bar.css('transition', seconds + 's linear');
+ button.progressSet(99);
+
+ window.setTimeout(function () {
+ bar.css('transition', '');
+ button.progressFinish();
+
+ if ($.isFunction(cb)) {
+ cb();
+ }
+
+ }, seconds * 1000);
+ };
+
+ function PreLoad(imgs, options) {
+ this.imgs = (typeof imgs === 'string') ? [imgs] : imgs;
+ this.opts = $.extend({}, PreLoad.DEFAULTS, options);
+
+ if (this.opts.order === 'ordered') {
+ this._ordered();
+ } else {
+ this._unordered();
+ }
+ }
+
+ PreLoad.DEFAULTS = {
+ order: 'unordered', //无序预加载
+ each: null, //每张图片加载完毕后执行
+ all: null // 所有图片加载完毕后执行
+ };
+ PreLoad.prototype._ordered = function () {
+ var imgs = this.imgs,
+ opts = this.opts,
+ count = 0,
+ len = imgs.length;
+
+ function load() {
+ var imgObj = new Image();
+
+ $(imgObj).on('load error', function () {
+ opts.each && opts.each(count);
+ if (count >= len) {
+ //所有图片全部加载完成
+ opts.all && opts.all();
+ } else {
+ load();
+ }
+
+ count++;
+ });
+
+ imgObj.src = imgs[count];
+ }
+
+ load();
+ };
+ PreLoad.prototype._unordered = function () {//无序加载
+
+ var imgs = this.imgs,
+ opts = this.opts,
+ count = 0,
+ len = imgs.length;
+
+ $.each(imgs, function (i, src) {
+ if (typeof src != 'string') return;
+
+ var imgObj = new Image();
+
+ $(imgObj).on('load error', function () {
+
+ opts.each && opts.each(count);
+
+ if (count >= len - 1) {
+ opts.all && opts.all();
+ }
+ count++;
+ });
+
+ imgObj.src = src;
+ });
+ };
+
+
+ $.extend({
+ preLoad: function (imgs, opts) {
+ new PreLoad(imgs, opts);
+ }
+ });
+
+})(jQuery);
diff --git a/solar/js/libs/FirstPersonControls.js b/solar/js/libs/FirstPersonControls.js
new file mode 100644
index 0000000..51e0c39
--- /dev/null
+++ b/solar/js/libs/FirstPersonControls.js
@@ -0,0 +1,300 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ * @author paulirish / http://paulirish.com/
+ */
+
+THREE.FirstPersonControls = function ( object, domElement ) {
+
+ this.object = object;
+ this.target = new THREE.Vector3( 0, 0, 0 );
+
+ this.domElement = ( domElement !== undefined ) ? domElement : document;
+
+ this.enabled = true;
+
+ this.movementSpeed = 1.0;
+ this.lookSpeed = 0.005;
+
+ this.lookVertical = true;
+ this.autoForward = false;
+
+ this.activeLook = true;
+
+ this.heightSpeed = false;
+ this.heightCoef = 1.0;
+ this.heightMin = 0.0;
+ this.heightMax = 1.0;
+
+ this.constrainVertical = false;
+ this.verticalMin = 0;
+ this.verticalMax = Math.PI;
+
+ this.autoSpeedFactor = 0.0;
+
+ this.mouseX = 0;
+ this.mouseY = 0;
+
+ this.lat = 0;
+ this.lon = 0;
+ this.phi = 0;
+ this.theta = 0;
+
+ this.moveForward = false;
+ this.moveBackward = false;
+ this.moveLeft = false;
+ this.moveRight = false;
+
+ this.mouseDragOn = false;
+
+ this.viewHalfX = 0;
+ this.viewHalfY = 0;
+
+ if ( this.domElement !== document ) {
+
+ this.domElement.setAttribute( 'tabindex', - 1 );
+
+ }
+
+ //
+
+ this.handleResize = function () {
+
+ if ( this.domElement === document ) {
+
+ this.viewHalfX = window.innerWidth / 2;
+ this.viewHalfY = window.innerHeight / 2;
+
+ } else {
+
+ this.viewHalfX = this.domElement.offsetWidth / 2;
+ this.viewHalfY = this.domElement.offsetHeight / 2;
+
+ }
+
+ };
+
+ this.onMouseDown = function ( event ) {
+
+ if ( this.domElement !== document ) {
+
+ this.domElement.focus();
+
+ }
+
+ event.preventDefault();
+ event.stopPropagation();
+
+ if ( this.activeLook ) {
+
+ switch ( event.button ) {
+
+ case 0: this.moveForward = true; break;
+ case 2: this.moveBackward = true; break;
+
+ }
+
+ }
+
+ this.mouseDragOn = true;
+
+ };
+
+ this.onMouseUp = function ( event ) {
+
+ event.preventDefault();
+ event.stopPropagation();
+
+ if ( this.activeLook ) {
+
+ switch ( event.button ) {
+
+ case 0: this.moveForward = false; break;
+ case 2: this.moveBackward = false; break;
+
+ }
+
+ }
+
+ this.mouseDragOn = false;
+
+ };
+
+ this.onMouseMove = function ( event ) {
+
+ if ( this.domElement === document ) {
+
+ this.mouseX = event.pageX - this.viewHalfX;
+ this.mouseY = event.pageY - this.viewHalfY;
+
+ } else {
+
+ this.mouseX = event.pageX - this.domElement.offsetLeft - this.viewHalfX;
+ this.mouseY = event.pageY - this.domElement.offsetTop - this.viewHalfY;
+
+ }
+
+ };
+
+ this.onKeyDown = function ( event ) {
+
+ //event.preventDefault();
+
+ switch ( event.keyCode ) {
+
+ case 38: /*up*/
+ case 87: /*W*/ this.moveForward = true; break;
+
+ case 37: /*left*/
+ case 65: /*A*/ this.moveLeft = true; break;
+
+ case 40: /*down*/
+ case 83: /*S*/ this.moveBackward = true; break;
+
+ case 39: /*right*/
+ case 68: /*D*/ this.moveRight = true; break;
+
+ case 82: /*R*/ this.moveUp = true; break;
+ case 70: /*F*/ this.moveDown = true; break;
+
+ }
+
+ };
+
+ this.onKeyUp = function ( event ) {
+
+ switch ( event.keyCode ) {
+
+ case 38: /*up*/
+ case 87: /*W*/ this.moveForward = false; break;
+
+ case 37: /*left*/
+ case 65: /*A*/ this.moveLeft = false; break;
+
+ case 40: /*down*/
+ case 83: /*S*/ this.moveBackward = false; break;
+
+ case 39: /*right*/
+ case 68: /*D*/ this.moveRight = false; break;
+
+ case 82: /*R*/ this.moveUp = false; break;
+ case 70: /*F*/ this.moveDown = false; break;
+
+ }
+
+ };
+
+ this.update = function( delta ) {
+
+ if ( this.enabled === false ) return;
+
+ if ( this.heightSpeed ) {
+
+ var y = THREE.Math.clamp( this.object.position.y, this.heightMin, this.heightMax );
+ var heightDelta = y - this.heightMin;
+
+ this.autoSpeedFactor = delta * ( heightDelta * this.heightCoef );
+
+ } else {
+
+ this.autoSpeedFactor = 0.0;
+
+ }
+
+ var actualMoveSpeed = delta * this.movementSpeed;
+
+ if ( this.moveForward || ( this.autoForward && ! this.moveBackward ) ) this.object.translateZ( - ( actualMoveSpeed + this.autoSpeedFactor ) );
+ if ( this.moveBackward ) this.object.translateZ( actualMoveSpeed );
+
+ if ( this.moveLeft ) this.object.translateX( - actualMoveSpeed );
+ if ( this.moveRight ) this.object.translateX( actualMoveSpeed );
+
+ if ( this.moveUp ) this.object.translateY( actualMoveSpeed );
+ if ( this.moveDown ) this.object.translateY( - actualMoveSpeed );
+
+ var actualLookSpeed = delta * this.lookSpeed;
+
+ if ( ! this.activeLook ) {
+
+ actualLookSpeed = 0;
+
+ }
+
+ var verticalLookRatio = 1;
+
+ if ( this.constrainVertical ) {
+
+ verticalLookRatio = Math.PI / ( this.verticalMax - this.verticalMin );
+
+ }
+
+ this.lon += this.mouseX * actualLookSpeed;
+ if ( this.lookVertical ) this.lat -= this.mouseY * actualLookSpeed * verticalLookRatio;
+
+ this.lat = Math.max( - 85, Math.min( 85, this.lat ) );
+ this.phi = THREE.Math.degToRad( 90 - this.lat );
+
+ this.theta = THREE.Math.degToRad( this.lon );
+
+ if ( this.constrainVertical ) {
+
+ this.phi = THREE.Math.mapLinear( this.phi, 0, Math.PI, this.verticalMin, this.verticalMax );
+
+ }
+
+ var targetPosition = this.target,
+ position = this.object.position;
+
+ targetPosition.x = position.x + 100 * Math.sin( this.phi ) * Math.cos( this.theta );
+ targetPosition.y = position.y + 100 * Math.cos( this.phi );
+ targetPosition.z = position.z + 100 * Math.sin( this.phi ) * Math.sin( this.theta );
+
+ this.object.lookAt( targetPosition );
+
+ };
+
+ function contextmenu( event ) {
+
+ event.preventDefault();
+
+ }
+
+ this.dispose = function() {
+
+ this.domElement.removeEventListener( 'contextmenu', contextmenu, false );
+ this.domElement.removeEventListener( 'mousedown', _onMouseDown, false );
+ this.domElement.removeEventListener( 'mousemove', _onMouseMove, false );
+ this.domElement.removeEventListener( 'mouseup', _onMouseUp, false );
+
+ window.removeEventListener( 'keydown', _onKeyDown, false );
+ window.removeEventListener( 'keyup', _onKeyUp, false );
+
+ };
+
+ var _onMouseMove = bind( this, this.onMouseMove );
+ var _onMouseDown = bind( this, this.onMouseDown );
+ var _onMouseUp = bind( this, this.onMouseUp );
+ var _onKeyDown = bind( this, this.onKeyDown );
+ var _onKeyUp = bind( this, this.onKeyUp );
+
+ this.domElement.addEventListener( 'contextmenu', contextmenu, false );
+ this.domElement.addEventListener( 'mousemove', _onMouseMove, false );
+ this.domElement.addEventListener( 'mousedown', _onMouseDown, false );
+ this.domElement.addEventListener( 'mouseup', _onMouseUp, false );
+
+ window.addEventListener( 'keydown', _onKeyDown, false );
+ window.addEventListener( 'keyup', _onKeyUp, false );
+
+ function bind( scope, fn ) {
+
+ return function () {
+
+ fn.apply( scope, arguments );
+
+ };
+
+ }
+
+ this.handleResize();
+
+};
diff --git a/solar/js/libs/GPUParticleSystem.js b/solar/js/libs/GPUParticleSystem.js
new file mode 100644
index 0000000..8147596
--- /dev/null
+++ b/solar/js/libs/GPUParticleSystem.js
@@ -0,0 +1,501 @@
+/*
+ * GPU Particle System
+ * @author flimshaw - Charlie Hoey - http://charliehoey.com
+ *
+ * A simple to use, general purpose GPU system. Particles are spawn-and-forget with
+ * several options available, and do not require monitoring or cleanup after spawning.
+ * Because the paths of all particles are completely deterministic once spawned, the scale
+ * and direction of time is also variable.
+ *
+ * Currently uses a static wrapping perlin noise texture for turbulence, and a small png texture for
+ * particles, but adding support for a particle texture atlas or changing to a different type of turbulence
+ * would be a fairly light day's work.
+ *
+ * Shader and javascript packing code derrived from several Stack Overflow examples.
+ *
+ */
+
+THREE.GPUParticleSystem = function( options ) {
+
+ THREE.Object3D.apply( this, arguments );
+
+ options = options || {};
+
+ // parse options and use defaults
+
+ this.PARTICLE_COUNT = options.maxParticles || 1000000;
+ this.PARTICLE_CONTAINERS = options.containerCount || 1;
+
+ this.PARTICLE_NOISE_TEXTURE = options.particleNoiseTex || null;
+ this.PARTICLE_SPRITE_TEXTURE = options.particleSpriteTex || null;
+
+ this.PARTICLES_PER_CONTAINER = Math.ceil( this.PARTICLE_COUNT / this.PARTICLE_CONTAINERS );
+ this.PARTICLE_CURSOR = 0;
+ this.time = 0;
+ this.particleContainers = [];
+ this.rand = [];
+
+ // custom vertex and fragement shader
+
+ var GPUParticleShader = {
+
+ vertexShader: [
+
+ 'uniform float uTime;',
+ 'uniform float uScale;',
+ 'uniform sampler2D tNoise;',
+
+ 'attribute vec3 positionStart;',
+ 'attribute float startTime;',
+ 'attribute vec3 velocity;',
+ 'attribute float turbulence;',
+ 'attribute vec3 color;',
+ 'attribute float size;',
+ 'attribute float lifeTime;',
+
+ 'varying vec4 vColor;',
+ 'varying float lifeLeft;',
+
+ 'void main() {',
+
+ // unpack things from our attributes'
+
+ ' vColor = vec4( color, 1.0 );',
+
+ // convert our velocity back into a value we can use'
+
+ ' vec3 newPosition;',
+ ' vec3 v;',
+
+ ' float timeElapsed = uTime - startTime;',
+
+ ' lifeLeft = 1.0 - ( timeElapsed / lifeTime );',
+
+ ' gl_PointSize = ( uScale * size ) * lifeLeft;',
+
+ ' v.x = ( velocity.x - 0.5 ) * 3.0;',
+ ' v.y = ( velocity.y - 0.5 ) * 3.0;',
+ ' v.z = ( velocity.z - 0.5 ) * 3.0;',
+
+ ' newPosition = positionStart + ( v * 10.0 ) * timeElapsed;',
+
+ ' vec3 noise = texture2D( tNoise, vec2( newPosition.x * 0.015 + ( uTime * 0.05 ), newPosition.y * 0.02 + ( uTime * 0.015 ) ) ).rgb;',
+ ' vec3 noiseVel = ( noise.rgb - 0.5 ) * 30.0;',
+
+ ' newPosition = mix( newPosition, newPosition + vec3( noiseVel * ( turbulence * 5.0 ) ), ( timeElapsed / lifeTime ) );',
+
+ ' if( v.y > 0. && v.y < .05 ) {',
+
+ ' lifeLeft = 0.0;',
+
+ ' }',
+
+ ' if( v.x < - 1.45 ) {',
+
+ ' lifeLeft = 0.0;',
+
+ ' }',
+
+ ' if( timeElapsed > 0.0 ) {',
+
+ ' gl_Position = projectionMatrix * modelViewMatrix * vec4( newPosition, 1.0 );',
+
+ ' } else {',
+
+ ' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+ ' lifeLeft = 0.0;',
+ ' gl_PointSize = 0.;',
+
+ ' }',
+
+ '}'
+
+ ].join( '\n' ),
+
+ fragmentShader: [
+
+ 'float scaleLinear( float value, vec2 valueDomain ) {',
+
+ ' return ( value - valueDomain.x ) / ( valueDomain.y - valueDomain.x );',
+
+ '}',
+
+ 'float scaleLinear( float value, vec2 valueDomain, vec2 valueRange ) {',
+
+ ' return mix( valueRange.x, valueRange.y, scaleLinear( value, valueDomain ) );',
+
+ '}',
+
+ 'varying vec4 vColor;',
+ 'varying float lifeLeft;',
+
+ 'uniform sampler2D tSprite;',
+
+ 'void main() {',
+
+ ' float alpha = 0.;',
+
+ ' if( lifeLeft > 0.995 ) {',
+
+ ' alpha = scaleLinear( lifeLeft, vec2( 1.0, 0.995 ), vec2( 0.0, 1.0 ) );',
+
+ ' } else {',
+
+ ' alpha = lifeLeft * 0.75;',
+
+ ' }',
+
+ ' vec4 tex = texture2D( tSprite, gl_PointCoord );',
+ ' gl_FragColor = vec4( vColor.rgb * tex.a, alpha * tex.a );',
+
+ '}'
+
+ ].join( '\n' )
+
+ };
+
+ // preload a million random numbers
+
+ var i;
+
+ for ( i = 1e5; i > 0; i-- ) {
+
+ this.rand.push( Math.random() - 0.5 );
+
+ }
+
+ this.random = function() {
+
+ return ++ i >= this.rand.length ? this.rand[ i = 1 ] : this.rand[ i ];
+
+ };
+
+ var textureLoader = new THREE.TextureLoader();
+
+ this.particleNoiseTex = this.PARTICLE_NOISE_TEXTURE || textureLoader.load( 'res/comet/perlin-512.png' );
+ this.particleNoiseTex.wrapS = this.particleNoiseTex.wrapT = THREE.RepeatWrapping;
+
+ this.particleSpriteTex = this.PARTICLE_SPRITE_TEXTURE || textureLoader.load( 'res/comet/particle2.png' );
+ this.particleSpriteTex.wrapS = this.particleSpriteTex.wrapT = THREE.RepeatWrapping;
+
+ this.particleShaderMat = new THREE.ShaderMaterial( {
+ transparent: true,
+ depthWrite: false,
+ uniforms: {
+ 'uTime': {
+ value: 0.0
+ },
+ 'uScale': {
+ value: 1.0
+ },
+ 'tNoise': {
+ value: this.particleNoiseTex
+ },
+ 'tSprite': {
+ value: this.particleSpriteTex
+ }
+ },
+ blending: THREE.AdditiveBlending,
+ vertexShader: GPUParticleShader.vertexShader,
+ fragmentShader: GPUParticleShader.fragmentShader
+ } );
+
+ // define defaults for all values
+
+ this.particleShaderMat.defaultAttributeValues.particlePositionsStartTime = [ 0, 0, 0, 0 ];
+ this.particleShaderMat.defaultAttributeValues.particleVelColSizeLife = [ 0, 0, 0, 0 ];
+
+ this.init = function() {
+
+ for ( var i = 0; i < this.PARTICLE_CONTAINERS; i ++ ) {
+
+ var c = new THREE.GPUParticleContainer( this.PARTICLES_PER_CONTAINER, this );
+ this.particleContainers.push( c );
+ this.add( c );
+
+ }
+
+ };
+
+ this.spawnParticle = function( options ) {
+
+ this.PARTICLE_CURSOR ++;
+
+ if ( this.PARTICLE_CURSOR >= this.PARTICLE_COUNT ) {
+
+ this.PARTICLE_CURSOR = 1;
+
+ }
+
+ var currentContainer = this.particleContainers[ Math.floor( this.PARTICLE_CURSOR / this.PARTICLES_PER_CONTAINER ) ];
+
+ currentContainer.spawnParticle( options );
+
+ };
+
+ this.update = function( time ) {
+
+ for ( var i = 0; i < this.PARTICLE_CONTAINERS; i ++ ) {
+
+ this.particleContainers[ i ].update( time );
+
+ }
+
+ };
+
+ this.dispose = function() {
+
+ this.particleShaderMat.dispose();
+ this.particleNoiseTex.dispose();
+ this.particleSpriteTex.dispose();
+
+ for ( var i = 0; i < this.PARTICLE_CONTAINERS; i ++ ) {
+
+ this.particleContainers[ i ].dispose();
+
+ }
+
+ };
+
+ this.init();
+
+};
+
+THREE.GPUParticleSystem.prototype = Object.create( THREE.Object3D.prototype );
+THREE.GPUParticleSystem.prototype.constructor = THREE.GPUParticleSystem;
+
+
+// Subclass for particle containers, allows for very large arrays to be spread out
+
+THREE.GPUParticleContainer = function( maxParticles, particleSystem ) {
+
+ THREE.Object3D.apply( this, arguments );
+
+ this.PARTICLE_COUNT = maxParticles || 100000;
+ this.PARTICLE_CURSOR = 0;
+ this.time = 0;
+ this.offset = 0;
+ this.count = 0;
+ this.DPR = window.devicePixelRatio;
+ this.GPUParticleSystem = particleSystem;
+ this.particleUpdate = false;
+
+ // geometry
+
+ this.particleShaderGeo = new THREE.BufferGeometry();
+
+ this.particleShaderGeo.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'positionStart', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'startTime', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'velocity', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'turbulence', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'color', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT * 3 ), 3 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'size', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+ this.particleShaderGeo.addAttribute( 'lifeTime', new THREE.BufferAttribute( new Float32Array( this.PARTICLE_COUNT ), 1 ).setDynamic( true ) );
+
+ // material
+
+ this.particleShaderMat = this.GPUParticleSystem.particleShaderMat;
+
+ var position = new THREE.Vector3();
+ var velocity = new THREE.Vector3();
+ var color = new THREE.Color();
+
+ this.spawnParticle = function( options ) {
+
+ var positionStartAttribute = this.particleShaderGeo.getAttribute( 'positionStart' );
+ var startTimeAttribute = this.particleShaderGeo.getAttribute( 'startTime' );
+ var velocityAttribute = this.particleShaderGeo.getAttribute( 'velocity' );
+ var turbulenceAttribute = this.particleShaderGeo.getAttribute( 'turbulence' );
+ var colorAttribute = this.particleShaderGeo.getAttribute( 'color' );
+ var sizeAttribute = this.particleShaderGeo.getAttribute( 'size' );
+ var lifeTimeAttribute = this.particleShaderGeo.getAttribute( 'lifeTime' );
+
+ options = options || {};
+
+ // setup reasonable default values for all arguments
+
+ position = options.position !== undefined ? position.copy( options.position ) : position.set( 0, 0, 0 );
+ velocity = options.velocity !== undefined ? velocity.copy( options.velocity ) : velocity.set( 0, 0, 0 );
+ color = options.color !== undefined ? color.set( options.color ) : color.set( 0xffffff );
+
+ var positionRandomness = options.positionRandomness !== undefined ? options.positionRandomness : 0;
+ var velocityRandomness = options.velocityRandomness !== undefined ? options.velocityRandomness : 0;
+ var colorRandomness = options.colorRandomness !== undefined ? options.colorRandomness : 1;
+ var turbulence = options.turbulence !== undefined ? options.turbulence : 1;
+ var lifetime = options.lifetime !== undefined ? options.lifetime : 5;
+ var size = options.size !== undefined ? options.size : 10;
+ var sizeRandomness = options.sizeRandomness !== undefined ? options.sizeRandomness : 0;
+ var smoothPosition = options.smoothPosition !== undefined ? options.smoothPosition : false;
+
+ if ( this.DPR !== undefined ) size *= this.DPR;
+
+ var i = this.PARTICLE_CURSOR;
+
+ // position
+
+ positionStartAttribute.array[ i * 3 + 0 ] = position.x + ( particleSystem.random() * positionRandomness );
+ positionStartAttribute.array[ i * 3 + 1 ] = position.y + ( particleSystem.random() * positionRandomness );
+ positionStartAttribute.array[ i * 3 + 2 ] = position.z + ( particleSystem.random() * positionRandomness );
+
+ if ( smoothPosition === true ) {
+
+ positionStartAttribute.array[ i * 3 + 0 ] += - ( velocity.x * particleSystem.random() );
+ positionStartAttribute.array[ i * 3 + 1 ] += - ( velocity.y * particleSystem.random() );
+ positionStartAttribute.array[ i * 3 + 2 ] += - ( velocity.z * particleSystem.random() );
+
+ }
+
+ // velocity
+
+ var maxVel = 2;
+
+ var velX = velocity.x + particleSystem.random() * velocityRandomness;
+ var velY = velocity.y + particleSystem.random() * velocityRandomness;
+ var velZ = velocity.z + particleSystem.random() * velocityRandomness;
+
+ velX = THREE.Math.clamp( ( velX - ( - maxVel ) ) / ( maxVel - ( - maxVel ) ), 0, 1 );
+ velY = THREE.Math.clamp( ( velY - ( - maxVel ) ) / ( maxVel - ( - maxVel ) ), 0, 1 );
+ velZ = THREE.Math.clamp( ( velZ - ( - maxVel ) ) / ( maxVel - ( - maxVel ) ), 0, 1 );
+
+ velocityAttribute.array[ i * 3 + 0 ] = velX;
+ velocityAttribute.array[ i * 3 + 1 ] = velY;
+ velocityAttribute.array[ i * 3 + 2 ] = velZ;
+
+ // color
+
+ color.r = THREE.Math.clamp( color.r + particleSystem.random() * colorRandomness, 0, 1 );
+ color.g = THREE.Math.clamp( color.g + particleSystem.random() * colorRandomness, 0, 1 );
+ color.b = THREE.Math.clamp( color.b + particleSystem.random() * colorRandomness, 0, 1 );
+
+ colorAttribute.array[ i * 3 + 0 ] = color.r;
+ colorAttribute.array[ i * 3 + 1 ] = color.g;
+ colorAttribute.array[ i * 3 + 2 ] = color.b;
+
+ // turbulence, size, lifetime and starttime
+
+ turbulenceAttribute.array[ i ] = turbulence;
+ sizeAttribute.array[ i ] = size + particleSystem.random() * sizeRandomness;
+ lifeTimeAttribute.array[ i ] = lifetime;
+ startTimeAttribute.array[ i ] = this.time + particleSystem.random() * 2e-2;
+
+ // offset
+
+ if ( this.offset === 0 ) {
+
+ this.offset = this.PARTICLE_CURSOR;
+
+ }
+
+ // counter and cursor
+
+ this.count ++;
+ this.PARTICLE_CURSOR ++;
+
+ if ( this.PARTICLE_CURSOR >= this.PARTICLE_COUNT ) {
+
+ this.PARTICLE_CURSOR = 0;
+
+ }
+
+ this.particleUpdate = true;
+
+ };
+
+ this.init = function() {
+
+ this.particleSystem = new THREE.Points( this.particleShaderGeo, this.particleShaderMat );
+ this.particleSystem.frustumCulled = false;
+ this.add( this.particleSystem );
+
+ };
+
+ this.update = function( time ) {
+
+ this.time = time;
+ this.particleShaderMat.uniforms.uTime.value = time;
+
+ this.geometryUpdate();
+
+ };
+
+ this.geometryUpdate = function() {
+
+ if ( this.particleUpdate === true ) {
+
+ this.particleUpdate = false;
+
+ var positionStartAttribute = this.particleShaderGeo.getAttribute( 'positionStart' );
+ var startTimeAttribute = this.particleShaderGeo.getAttribute( 'startTime' );
+ var velocityAttribute = this.particleShaderGeo.getAttribute( 'velocity' );
+ var turbulenceAttribute = this.particleShaderGeo.getAttribute( 'turbulence' );
+ var colorAttribute = this.particleShaderGeo.getAttribute( 'color' );
+ var sizeAttribute = this.particleShaderGeo.getAttribute( 'size' );
+ var lifeTimeAttribute = this.particleShaderGeo.getAttribute( 'lifeTime' );
+
+ if ( this.offset + this.count < this.PARTICLE_COUNT ) {
+
+ positionStartAttribute.updateRange.offset = this.offset * positionStartAttribute.itemSize;
+ startTimeAttribute.updateRange.offset = this.offset * startTimeAttribute.itemSize;
+ velocityAttribute.updateRange.offset = this.offset * velocityAttribute.itemSize;
+ turbulenceAttribute.updateRange.offset = this.offset * turbulenceAttribute.itemSize;
+ colorAttribute.updateRange.offset = this.offset * colorAttribute.itemSize;
+ sizeAttribute.updateRange.offset = this.offset * sizeAttribute.itemSize;
+ lifeTimeAttribute.updateRange.offset = this.offset * lifeTimeAttribute.itemSize;
+
+ positionStartAttribute.updateRange.count = this.count * positionStartAttribute.itemSize;
+ startTimeAttribute.updateRange.count = this.count * startTimeAttribute.itemSize;
+ velocityAttribute.updateRange.count = this.count * velocityAttribute.itemSize;
+ turbulenceAttribute.updateRange.count = this.count * turbulenceAttribute.itemSize;
+ colorAttribute.updateRange.count = this.count * colorAttribute.itemSize;
+ sizeAttribute.updateRange.count = this.count * sizeAttribute.itemSize;
+ lifeTimeAttribute.updateRange.count = this.count * lifeTimeAttribute.itemSize;
+
+ } else {
+
+ positionStartAttribute.updateRange.offset = 0;
+ startTimeAttribute.updateRange.offset = 0;
+ velocityAttribute.updateRange.offset = 0;
+ turbulenceAttribute.updateRange.offset = 0;
+ colorAttribute.updateRange.offset = 0;
+ sizeAttribute.updateRange.offset = 0;
+ lifeTimeAttribute.updateRange.offset = 0;
+
+ // Use -1 to update the entire buffer, see #11476
+ positionStartAttribute.updateRange.count = -1;
+ startTimeAttribute.updateRange.count = -1;
+ velocityAttribute.updateRange.count = -1;
+ turbulenceAttribute.updateRange.count = -1;
+ colorAttribute.updateRange.count = -1;
+ sizeAttribute.updateRange.count = -1;
+ lifeTimeAttribute.updateRange.count = -1;
+
+ }
+
+ positionStartAttribute.needsUpdate = true;
+ startTimeAttribute.needsUpdate = true;
+ velocityAttribute.needsUpdate = true;
+ turbulenceAttribute.needsUpdate = true;
+ colorAttribute.needsUpdate = true;
+ sizeAttribute.needsUpdate = true;
+ lifeTimeAttribute.needsUpdate = true;
+
+ this.offset = 0;
+ this.count = 0;
+
+ }
+
+ };
+
+ this.dispose = function() {
+
+ this.particleShaderGeo.dispose();
+
+ };
+
+ this.init();
+
+};
+
+THREE.GPUParticleContainer.prototype = Object.create( THREE.Object3D.prototype );
+THREE.GPUParticleContainer.prototype.constructor = THREE.GPUParticleContainer;
diff --git a/solar/js/libs/MTLLoader.js b/solar/js/libs/MTLLoader.js
new file mode 100644
index 0000000..c2ae70a
--- /dev/null
+++ b/solar/js/libs/MTLLoader.js
@@ -0,0 +1,551 @@
+/**
+ * Loads a Wavefront .mtl file specifying materials
+ *
+ * @author angelxuanchang
+ */
+
+THREE.MTLLoader = function ( manager ) {
+
+ this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.MTLLoader.prototype = {
+
+ constructor: THREE.MTLLoader,
+
+ /**
+ * Loads and parses a MTL asset from a URL.
+ *
+ * @param {String} url - URL to the MTL file.
+ * @param {Function} [onLoad] - Callback invoked with the loaded object.
+ * @param {Function} [onProgress] - Callback for download progress.
+ * @param {Function} [onError] - Callback for download errors.
+ *
+ * @see setPath setTexturePath
+ *
+ * @note In order for relative texture references to resolve correctly
+ * you must call setPath and/or setTexturePath explicitly prior to load.
+ */
+ load: function ( url, onLoad, onProgress, onError ) {
+
+ var scope = this;
+
+ var loader = new THREE.FileLoader( this.manager );
+ loader.setPath( this.path );
+ loader.load( url, function ( text ) {
+
+ onLoad( scope.parse( text ) );
+
+ }, onProgress, onError );
+
+ },
+
+ /**
+ * Set base path for resolving references.
+ * If set this path will be prepended to each loaded and found reference.
+ *
+ * @see setTexturePath
+ * @param {String} path
+ *
+ * @example
+ * mtlLoader.setPath( 'assets/obj/' );
+ * mtlLoader.load( 'my.mtl', ... );
+ */
+ setPath: function ( path ) {
+
+ this.path = path;
+
+ },
+
+ /**
+ * Set base path for resolving texture references.
+ * If set this path will be prepended found texture reference.
+ * If not set and setPath is, it will be used as texture base path.
+ *
+ * @see setPath
+ * @param {String} path
+ *
+ * @example
+ * mtlLoader.setPath( 'assets/obj/' );
+ * mtlLoader.setTexturePath( 'assets/textures/' );
+ * mtlLoader.load( 'my.mtl', ... );
+ */
+ setTexturePath: function ( path ) {
+
+ this.texturePath = path;
+
+ },
+
+ setBaseUrl: function ( path ) {
+
+ console.warn( 'THREE.MTLLoader: .setBaseUrl() is deprecated. Use .setTexturePath( path ) for texture path or .setPath( path ) for general base path instead.' );
+
+ this.setTexturePath( path );
+
+ },
+
+ setCrossOrigin: function ( value ) {
+
+ this.crossOrigin = value;
+
+ },
+
+ setMaterialOptions: function ( value ) {
+
+ this.materialOptions = value;
+
+ },
+
+ /**
+ * Parses a MTL file.
+ *
+ * @param {String} text - Content of MTL file
+ * @return {THREE.MTLLoader.MaterialCreator}
+ *
+ * @see setPath setTexturePath
+ *
+ * @note In order for relative texture references to resolve correctly
+ * you must call setPath and/or setTexturePath explicitly prior to parse.
+ */
+ parse: function ( text ) {
+
+ var lines = text.split( '\n' );
+ var info = {};
+ var delimiter_pattern = /\s+/;
+ var materialsInfo = {};
+
+ for ( var i = 0; i < lines.length; i ++ ) {
+
+ var line = lines[ i ];
+ line = line.trim();
+
+ if ( line.length === 0 || line.charAt( 0 ) === '#' ) {
+
+ // Blank line or comment ignore
+ continue;
+
+ }
+
+ var pos = line.indexOf( ' ' );
+
+ var key = ( pos >= 0 ) ? line.substring( 0, pos ) : line;
+ key = key.toLowerCase();
+
+ var value = ( pos >= 0 ) ? line.substring( pos + 1 ) : '';
+ value = value.trim();
+
+ if ( key === 'newmtl' ) {
+
+ // New material
+
+ info = { name: value };
+ materialsInfo[ value ] = info;
+
+ } else if ( info ) {
+
+ if ( key === 'ka' || key === 'kd' || key === 'ks' ) {
+
+ var ss = value.split( delimiter_pattern, 3 );
+ info[ key ] = [ parseFloat( ss[ 0 ] ), parseFloat( ss[ 1 ] ), parseFloat( ss[ 2 ] ) ];
+
+ } else {
+
+ info[ key ] = value;
+
+ }
+
+ }
+
+ }
+
+ var materialCreator = new THREE.MTLLoader.MaterialCreator( this.texturePath || this.path, this.materialOptions );
+ materialCreator.setCrossOrigin( this.crossOrigin );
+ materialCreator.setManager( this.manager );
+ materialCreator.setMaterials( materialsInfo );
+ return materialCreator;
+
+ }
+
+};
+
+/**
+ * Create a new THREE-MTLLoader.MaterialCreator
+ * @param baseUrl - Url relative to which textures are loaded
+ * @param options - Set of options on how to construct the materials
+ * side: Which side to apply the material
+ * THREE.FrontSide (default), THREE.BackSide, THREE.DoubleSide
+ * wrap: What type of wrapping to apply for textures
+ * THREE.RepeatWrapping (default), THREE.ClampToEdgeWrapping, THREE.MirroredRepeatWrapping
+ * normalizeRGB: RGBs need to be normalized to 0-1 from 0-255
+ * Default: false, assumed to be already normalized
+ * ignoreZeroRGBs: Ignore values of RGBs (Ka,Kd,Ks) that are all 0's
+ * Default: false
+ * @constructor
+ */
+
+THREE.MTLLoader.MaterialCreator = function ( baseUrl, options ) {
+
+ this.baseUrl = baseUrl || '';
+ this.options = options;
+ this.materialsInfo = {};
+ this.materials = {};
+ this.materialsArray = [];
+ this.nameLookup = {};
+
+ this.side = ( this.options && this.options.side ) ? this.options.side : THREE.FrontSide;
+ this.wrap = ( this.options && this.options.wrap ) ? this.options.wrap : THREE.RepeatWrapping;
+
+};
+
+THREE.MTLLoader.MaterialCreator.prototype = {
+
+ constructor: THREE.MTLLoader.MaterialCreator,
+
+ crossOrigin: 'Anonymous',
+
+ setCrossOrigin: function ( value ) {
+
+ this.crossOrigin = value;
+
+ },
+
+ setManager: function ( value ) {
+
+ this.manager = value;
+
+ },
+
+ setMaterials: function ( materialsInfo ) {
+
+ this.materialsInfo = this.convert( materialsInfo );
+ this.materials = {};
+ this.materialsArray = [];
+ this.nameLookup = {};
+
+ },
+
+ convert: function ( materialsInfo ) {
+
+ if ( ! this.options ) return materialsInfo;
+
+ var converted = {};
+
+ for ( var mn in materialsInfo ) {
+
+ // Convert materials info into normalized form based on options
+
+ var mat = materialsInfo[ mn ];
+
+ var covmat = {};
+
+ converted[ mn ] = covmat;
+
+ for ( var prop in mat ) {
+
+ var save = true;
+ var value = mat[ prop ];
+ var lprop = prop.toLowerCase();
+
+ switch ( lprop ) {
+
+ case 'kd':
+ case 'ka':
+ case 'ks':
+
+ // Diffuse color (color under white light) using RGB values
+
+ if ( this.options && this.options.normalizeRGB ) {
+
+ value = [ value[ 0 ] / 255, value[ 1 ] / 255, value[ 2 ] / 255 ];
+
+ }
+
+ if ( this.options && this.options.ignoreZeroRGBs ) {
+
+ if ( value[ 0 ] === 0 && value[ 1 ] === 0 && value[ 2 ] === 0 ) {
+
+ // ignore
+
+ save = false;
+
+ }
+
+ }
+
+ break;
+
+ default:
+
+ break;
+
+ }
+
+ if ( save ) {
+
+ covmat[ lprop ] = value;
+
+ }
+
+ }
+
+ }
+
+ return converted;
+
+ },
+
+ preload: function () {
+
+ for ( var mn in this.materialsInfo ) {
+
+ this.create( mn );
+
+ }
+
+ },
+
+ getIndex: function ( materialName ) {
+
+ return this.nameLookup[ materialName ];
+
+ },
+
+ getAsArray: function () {
+
+ var index = 0;
+
+ for ( var mn in this.materialsInfo ) {
+
+ this.materialsArray[ index ] = this.create( mn );
+ this.nameLookup[ mn ] = index;
+ index ++;
+
+ }
+
+ return this.materialsArray;
+
+ },
+
+ create: function ( materialName ) {
+
+ if ( this.materials[ materialName ] === undefined ) {
+
+ this.createMaterial_( materialName );
+
+ }
+
+ return this.materials[ materialName ];
+
+ },
+
+ createMaterial_: function ( materialName ) {
+
+ // Create material
+
+ var scope = this;
+ var mat = this.materialsInfo[ materialName ];
+ var params = {
+
+ name: materialName,
+ side: this.side
+
+ };
+
+ function resolveURL( baseUrl, url ) {
+
+ if ( typeof url !== 'string' || url === '' )
+ return '';
+
+ // Absolute URL
+ if ( /^https?:\/\//i.test( url ) ) return url;
+
+ return baseUrl + url;
+
+ }
+
+ function setMapForType( mapType, value ) {
+
+ if ( params[ mapType ] ) return; // Keep the first encountered texture
+
+ var texParams = scope.getTextureParams( value, params );
+ var map = scope.loadTexture( resolveURL( scope.baseUrl, texParams.url ) );
+
+ map.repeat.copy( texParams.scale );
+ map.offset.copy( texParams.offset );
+
+ map.wrapS = scope.wrap;
+ map.wrapT = scope.wrap;
+
+ params[ mapType ] = map;
+
+ }
+
+ for ( var prop in mat ) {
+
+ var value = mat[ prop ];
+ var n;
+
+ if ( value === '' ) continue;
+
+ switch ( prop.toLowerCase() ) {
+
+ // Ns is material specular exponent
+
+ case 'kd':
+
+ // Diffuse color (color under white light) using RGB values
+
+ params.color = new THREE.Color().fromArray( value );
+
+ break;
+
+ case 'ks':
+
+ // Specular color (color when light is reflected from shiny surface) using RGB values
+ params.specular = new THREE.Color().fromArray( value );
+
+ break;
+
+ case 'map_kd':
+
+ // Diffuse texture map
+
+ setMapForType( "map", value );
+
+ break;
+
+ case 'map_ks':
+
+ // Specular map
+
+ setMapForType( "specularMap", value );
+
+ break;
+
+ case 'norm':
+
+ setMapForType( "normalMap", value );
+
+ break;
+
+ case 'map_bump':
+ case 'bump':
+
+ // Bump texture map
+
+ setMapForType( "bumpMap", value );
+
+ break;
+
+ case 'ns':
+
+ // The specular exponent (defines the focus of the specular highlight)
+ // A high exponent results in a tight, concentrated highlight. Ns values normally range from 0 to 1000.
+
+ params.shininess = parseFloat( value );
+
+ break;
+
+ case 'd':
+ n = parseFloat( value );
+
+ if ( n < 1 ) {
+
+ params.opacity = n;
+ params.transparent = true;
+
+ }
+
+ break;
+
+ case 'tr':
+ n = parseFloat( value );
+
+ if ( n > 0 ) {
+
+ params.opacity = 1 - n;
+ params.transparent = true;
+
+ }
+
+ break;
+
+ default:
+ break;
+
+ }
+
+ }
+
+ this.materials[ materialName ] = new THREE.MeshPhongMaterial( params );
+ return this.materials[ materialName ];
+
+ },
+
+ getTextureParams: function ( value, matParams ) {
+
+ var texParams = {
+
+ scale: new THREE.Vector2( 1, 1 ),
+ offset: new THREE.Vector2( 0, 0 )
+
+ };
+
+ var items = value.split( /\s+/ );
+ var pos;
+
+ pos = items.indexOf( '-bm' );
+
+ if ( pos >= 0 ) {
+
+ matParams.bumpScale = parseFloat( items[ pos + 1 ] );
+ items.splice( pos, 2 );
+
+ }
+
+ pos = items.indexOf( '-s' );
+
+ if ( pos >= 0 ) {
+
+ texParams.scale.set( parseFloat( items[ pos + 1 ] ), parseFloat( items[ pos + 2 ] ) );
+ items.splice( pos, 4 ); // we expect 3 parameters here!
+
+ }
+
+ pos = items.indexOf( '-o' );
+
+ if ( pos >= 0 ) {
+
+ texParams.offset.set( parseFloat( items[ pos + 1 ] ), parseFloat( items[ pos + 2 ] ) );
+ items.splice( pos, 4 ); // we expect 3 parameters here!
+
+ }
+
+ texParams.url = items.join( ' ' ).trim();
+ return texParams;
+
+ },
+
+ loadTexture: function ( url, mapping, onLoad, onProgress, onError ) {
+
+ var texture;
+ var loader = THREE.Loader.Handlers.get( url );
+ var manager = ( this.manager !== undefined ) ? this.manager : THREE.DefaultLoadingManager;
+
+ if ( loader === null ) {
+
+ loader = new THREE.TextureLoader( manager );
+
+ }
+
+ if ( loader.setCrossOrigin ) loader.setCrossOrigin( this.crossOrigin );
+ texture = loader.load( url, onLoad, onProgress, onError );
+
+ if ( mapping !== undefined ) texture.mapping = mapping;
+
+ return texture;
+
+ }
+
+};
diff --git a/solar/js/libs/OBJLoader.js b/solar/js/libs/OBJLoader.js
new file mode 100644
index 0000000..daf80ff
--- /dev/null
+++ b/solar/js/libs/OBJLoader.js
@@ -0,0 +1,715 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.OBJLoader = ( function () {
+
+ // o object_name | g group_name
+ var object_pattern = /^[og]\s*(.+)?/;
+ // mtllib file_reference
+ var material_library_pattern = /^mtllib /;
+ // usemtl material_name
+ var material_use_pattern = /^usemtl /;
+
+ function ParserState() {
+
+ var state = {
+ objects: [],
+ object: {},
+
+ vertices: [],
+ normals: [],
+ colors: [],
+ uvs: [],
+
+ materialLibraries: [],
+
+ startObject: function ( name, fromDeclaration ) {
+
+ // If the current object (initial from reset) is not from a g/o declaration in the parsed
+ // file. We need to use it for the first parsed g/o to keep things in sync.
+ if ( this.object && this.object.fromDeclaration === false ) {
+
+ this.object.name = name;
+ this.object.fromDeclaration = ( fromDeclaration !== false );
+ return;
+
+ }
+
+ var previousMaterial = ( this.object && typeof this.object.currentMaterial === 'function' ? this.object.currentMaterial() : undefined );
+
+ if ( this.object && typeof this.object._finalize === 'function' ) {
+
+ this.object._finalize( true );
+
+ }
+
+ this.object = {
+ name: name || '',
+ fromDeclaration: ( fromDeclaration !== false ),
+
+ geometry: {
+ vertices: [],
+ normals: [],
+ colors: [],
+ uvs: []
+ },
+ materials: [],
+ smooth: true,
+
+ startMaterial: function ( name, libraries ) {
+
+ var previous = this._finalize( false );
+
+ // New usemtl declaration overwrites an inherited material, except if faces were declared
+ // after the material, then it must be preserved for proper MultiMaterial continuation.
+ if ( previous && ( previous.inherited || previous.groupCount <= 0 ) ) {
+
+ this.materials.splice( previous.index, 1 );
+
+ }
+
+ var material = {
+ index: this.materials.length,
+ name: name || '',
+ mtllib: ( Array.isArray( libraries ) && libraries.length > 0 ? libraries[ libraries.length - 1 ] : '' ),
+ smooth: ( previous !== undefined ? previous.smooth : this.smooth ),
+ groupStart: ( previous !== undefined ? previous.groupEnd : 0 ),
+ groupEnd: - 1,
+ groupCount: - 1,
+ inherited: false,
+
+ clone: function ( index ) {
+
+ var cloned = {
+ index: ( typeof index === 'number' ? index : this.index ),
+ name: this.name,
+ mtllib: this.mtllib,
+ smooth: this.smooth,
+ groupStart: 0,
+ groupEnd: - 1,
+ groupCount: - 1,
+ inherited: false
+ };
+ cloned.clone = this.clone.bind( cloned );
+ return cloned;
+
+ }
+ };
+
+ this.materials.push( material );
+
+ return material;
+
+ },
+
+ currentMaterial: function () {
+
+ if ( this.materials.length > 0 ) {
+
+ return this.materials[ this.materials.length - 1 ];
+
+ }
+
+ return undefined;
+
+ },
+
+ _finalize: function ( end ) {
+
+ var lastMultiMaterial = this.currentMaterial();
+ if ( lastMultiMaterial && lastMultiMaterial.groupEnd === - 1 ) {
+
+ lastMultiMaterial.groupEnd = this.geometry.vertices.length / 3;
+ lastMultiMaterial.groupCount = lastMultiMaterial.groupEnd - lastMultiMaterial.groupStart;
+ lastMultiMaterial.inherited = false;
+
+ }
+
+ // Ignore objects tail materials if no face declarations followed them before a new o/g started.
+ if ( end && this.materials.length > 1 ) {
+
+ for ( var mi = this.materials.length - 1; mi >= 0; mi -- ) {
+
+ if ( this.materials[ mi ].groupCount <= 0 ) {
+
+ this.materials.splice( mi, 1 );
+
+ }
+
+ }
+
+ }
+
+ // Guarantee at least one empty material, this makes the creation later more straight forward.
+ if ( end && this.materials.length === 0 ) {
+
+ this.materials.push( {
+ name: '',
+ smooth: this.smooth
+ } );
+
+ }
+
+ return lastMultiMaterial;
+
+ }
+ };
+
+ // Inherit previous objects material.
+ // Spec tells us that a declared material must be set to all objects until a new material is declared.
+ // If a usemtl declaration is encountered while this new object is being parsed, it will
+ // overwrite the inherited material. Exception being that there was already face declarations
+ // to the inherited material, then it will be preserved for proper MultiMaterial continuation.
+
+ if ( previousMaterial && previousMaterial.name && typeof previousMaterial.clone === 'function' ) {
+
+ var declared = previousMaterial.clone( 0 );
+ declared.inherited = true;
+ this.object.materials.push( declared );
+
+ }
+
+ this.objects.push( this.object );
+
+ },
+
+ finalize: function () {
+
+ if ( this.object && typeof this.object._finalize === 'function' ) {
+
+ this.object._finalize( true );
+
+ }
+
+ },
+
+ parseVertexIndex: function ( value, len ) {
+
+ var index = parseInt( value, 10 );
+ return ( index >= 0 ? index - 1 : index + len / 3 ) * 3;
+
+ },
+
+ parseNormalIndex: function ( value, len ) {
+
+ var index = parseInt( value, 10 );
+ return ( index >= 0 ? index - 1 : index + len / 3 ) * 3;
+
+ },
+
+ parseUVIndex: function ( value, len ) {
+
+ var index = parseInt( value, 10 );
+ return ( index >= 0 ? index - 1 : index + len / 2 ) * 2;
+
+ },
+
+ addVertex: function ( a, b, c ) {
+
+ var src = this.vertices;
+ var dst = this.object.geometry.vertices;
+
+ dst.push( src[ a + 0 ], src[ a + 1 ], src[ a + 2 ] );
+ dst.push( src[ b + 0 ], src[ b + 1 ], src[ b + 2 ] );
+ dst.push( src[ c + 0 ], src[ c + 1 ], src[ c + 2 ] );
+
+ },
+
+ addVertexLine: function ( a ) {
+
+ var src = this.vertices;
+ var dst = this.object.geometry.vertices;
+
+ dst.push( src[ a + 0 ], src[ a + 1 ], src[ a + 2 ] );
+
+ },
+
+ addNormal: function ( a, b, c ) {
+
+ var src = this.normals;
+ var dst = this.object.geometry.normals;
+
+ dst.push( src[ a + 0 ], src[ a + 1 ], src[ a + 2 ] );
+ dst.push( src[ b + 0 ], src[ b + 1 ], src[ b + 2 ] );
+ dst.push( src[ c + 0 ], src[ c + 1 ], src[ c + 2 ] );
+
+ },
+
+ addColor: function ( a, b, c ) {
+
+ var src = this.colors;
+ var dst = this.object.geometry.colors;
+
+ dst.push( src[ a + 0 ], src[ a + 1 ], src[ a + 2 ] );
+ dst.push( src[ b + 0 ], src[ b + 1 ], src[ b + 2 ] );
+ dst.push( src[ c + 0 ], src[ c + 1 ], src[ c + 2 ] );
+
+ },
+
+ addUV: function ( a, b, c ) {
+
+ var src = this.uvs;
+ var dst = this.object.geometry.uvs;
+
+ dst.push( src[ a + 0 ], src[ a + 1 ] );
+ dst.push( src[ b + 0 ], src[ b + 1 ] );
+ dst.push( src[ c + 0 ], src[ c + 1 ] );
+
+ },
+
+ addUVLine: function ( a ) {
+
+ var src = this.uvs;
+ var dst = this.object.geometry.uvs;
+
+ dst.push( src[ a + 0 ], src[ a + 1 ] );
+
+ },
+
+ addFace: function ( a, b, c, ua, ub, uc, na, nb, nc ) {
+
+ var vLen = this.vertices.length;
+
+ var ia = this.parseVertexIndex( a, vLen );
+ var ib = this.parseVertexIndex( b, vLen );
+ var ic = this.parseVertexIndex( c, vLen );
+
+ this.addVertex( ia, ib, ic );
+
+ if ( ua !== undefined ) {
+
+ var uvLen = this.uvs.length;
+
+ ia = this.parseUVIndex( ua, uvLen );
+ ib = this.parseUVIndex( ub, uvLen );
+ ic = this.parseUVIndex( uc, uvLen );
+
+ this.addUV( ia, ib, ic );
+
+ }
+
+ if ( na !== undefined ) {
+
+ // Normals are many times the same. If so, skip function call and parseInt.
+ var nLen = this.normals.length;
+ ia = this.parseNormalIndex( na, nLen );
+
+ ib = na === nb ? ia : this.parseNormalIndex( nb, nLen );
+ ic = na === nc ? ia : this.parseNormalIndex( nc, nLen );
+
+ this.addNormal( ia, ib, ic );
+
+ }
+
+ if ( this.colors.length > 0 ) {
+
+ this.addColor( ia, ib, ic );
+
+ }
+
+ },
+
+ addLineGeometry: function ( vertices, uvs ) {
+
+ this.object.geometry.type = 'Line';
+
+ var vLen = this.vertices.length;
+ var uvLen = this.uvs.length;
+
+ for ( var vi = 0, l = vertices.length; vi < l; vi ++ ) {
+
+ this.addVertexLine( this.parseVertexIndex( vertices[ vi ], vLen ) );
+
+ }
+
+ for ( var uvi = 0, l = uvs.length; uvi < l; uvi ++ ) {
+
+ this.addUVLine( this.parseUVIndex( uvs[ uvi ], uvLen ) );
+
+ }
+
+ }
+
+ };
+
+ state.startObject( '', false );
+
+ return state;
+
+ }
+
+ //
+
+ function OBJLoader( manager ) {
+
+ this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+ this.materials = null;
+
+ }
+
+ OBJLoader.prototype = {
+
+ constructor: OBJLoader,
+
+ load: function ( url, onLoad, onProgress, onError ) {
+
+ var scope = this;
+
+ var loader = new THREE.FileLoader( scope.manager );
+ loader.setPath( this.path );
+ loader.load( url, function ( text ) {
+
+ onLoad( scope.parse( text ) );
+
+ }, onProgress, onError );
+
+ },
+
+ setPath: function ( value ) {
+
+ this.path = value;
+
+ },
+
+ setMaterials: function ( materials ) {
+
+ this.materials = materials;
+
+ return this;
+
+ },
+
+ parse: function ( text ) {
+
+ console.time( 'OBJLoader' );
+
+ var state = new ParserState();
+
+ if ( text.indexOf( '\r\n' ) !== - 1 ) {
+
+ // This is faster than String.split with regex that splits on both
+ text = text.replace( /\r\n/g, '\n' );
+
+ }
+
+ if ( text.indexOf( '\\\n' ) !== - 1 ) {
+
+ // join lines separated by a line continuation character (\)
+ text = text.replace( /\\\n/g, '' );
+
+ }
+
+ var lines = text.split( '\n' );
+ var line = '', lineFirstChar = '';
+ var lineLength = 0;
+ var result = [];
+
+ // Faster to just trim left side of the line. Use if available.
+ var trimLeft = ( typeof ''.trimLeft === 'function' );
+
+ for ( var i = 0, l = lines.length; i < l; i ++ ) {
+
+ line = lines[ i ];
+
+ line = trimLeft ? line.trimLeft() : line.trim();
+
+ lineLength = line.length;
+
+ if ( lineLength === 0 ) continue;
+
+ lineFirstChar = line.charAt( 0 );
+
+ // @todo invoke passed in handler if any
+ if ( lineFirstChar === '#' ) continue;
+
+ if ( lineFirstChar === 'v' ) {
+
+ var data = line.split( /\s+/ );
+
+ switch ( data[ 0 ] ) {
+
+ case 'v':
+ state.vertices.push(
+ parseFloat( data[ 1 ] ),
+ parseFloat( data[ 2 ] ),
+ parseFloat( data[ 3 ] )
+ );
+ if ( data.length === 8 ) {
+
+ state.colors.push(
+ parseFloat( data[ 4 ] ),
+ parseFloat( data[ 5 ] ),
+ parseFloat( data[ 6 ] )
+
+ );
+
+ }
+ break;
+ case 'vn':
+ state.normals.push(
+ parseFloat( data[ 1 ] ),
+ parseFloat( data[ 2 ] ),
+ parseFloat( data[ 3 ] )
+ );
+ break;
+ case 'vt':
+ state.uvs.push(
+ parseFloat( data[ 1 ] ),
+ parseFloat( data[ 2 ] )
+ );
+ break;
+
+ }
+
+ } else if ( lineFirstChar === 'f' ) {
+
+ var lineData = line.substr( 1 ).trim();
+ var vertexData = lineData.split( /\s+/ );
+ var faceVertices = [];
+
+ // Parse the face vertex data into an easy to work with format
+
+ for ( var j = 0, jl = vertexData.length; j < jl; j ++ ) {
+
+ var vertex = vertexData[ j ];
+
+ if ( vertex.length > 0 ) {
+
+ var vertexParts = vertex.split( '/' );
+ faceVertices.push( vertexParts );
+
+ }
+
+ }
+
+ // Draw an edge between the first vertex and all subsequent vertices to form an n-gon
+
+ var v1 = faceVertices[ 0 ];
+
+ for ( var j = 1, jl = faceVertices.length - 1; j < jl; j ++ ) {
+
+ var v2 = faceVertices[ j ];
+ var v3 = faceVertices[ j + 1 ];
+
+ state.addFace(
+ v1[ 0 ], v2[ 0 ], v3[ 0 ],
+ v1[ 1 ], v2[ 1 ], v3[ 1 ],
+ v1[ 2 ], v2[ 2 ], v3[ 2 ]
+ );
+
+ }
+
+ } else if ( lineFirstChar === 'l' ) {
+
+ var lineParts = line.substring( 1 ).trim().split( " " );
+ var lineVertices = [], lineUVs = [];
+
+ if ( line.indexOf( "/" ) === - 1 ) {
+
+ lineVertices = lineParts;
+
+ } else {
+
+ for ( var li = 0, llen = lineParts.length; li < llen; li ++ ) {
+
+ var parts = lineParts[ li ].split( "/" );
+
+ if ( parts[ 0 ] !== "" ) lineVertices.push( parts[ 0 ] );
+ if ( parts[ 1 ] !== "" ) lineUVs.push( parts[ 1 ] );
+
+ }
+
+ }
+ state.addLineGeometry( lineVertices, lineUVs );
+
+ } else if ( ( result = object_pattern.exec( line ) ) !== null ) {
+
+ // o object_name
+ // or
+ // g group_name
+
+ // WORKAROUND: https://bugs.chromium.org/p/v8/issues/detail?id=2869
+ // var name = result[ 0 ].substr( 1 ).trim();
+ var name = ( " " + result[ 0 ].substr( 1 ).trim() ).substr( 1 );
+
+ state.startObject( name );
+
+ } else if ( material_use_pattern.test( line ) ) {
+
+ // material
+
+ state.object.startMaterial( line.substring( 7 ).trim(), state.materialLibraries );
+
+ } else if ( material_library_pattern.test( line ) ) {
+
+ // mtl file
+
+ state.materialLibraries.push( line.substring( 7 ).trim() );
+
+ } else if ( lineFirstChar === 's' ) {
+
+ result = line.split( ' ' );
+
+ // smooth shading
+
+ // @todo Handle files that have varying smooth values for a set of faces inside one geometry,
+ // but does not define a usemtl for each face set.
+ // This should be detected and a dummy material created (later MultiMaterial and geometry groups).
+ // This requires some care to not create extra material on each smooth value for "normal" obj files.
+ // where explicit usemtl defines geometry groups.
+ // Example asset: examples/models/obj/cerberus/Cerberus.obj
+
+ /*
+ * http://paulbourke.net/dataformats/obj/
+ * or
+ * http://www.cs.utah.edu/~boulos/cs3505/obj_spec.pdf
+ *
+ * From chapter "Grouping" Syntax explanation "s group_number":
+ * "group_number is the smoothing group number. To turn off smoothing groups, use a value of 0 or off.
+ * Polygonal elements use group numbers to put elements in different smoothing groups. For free-form
+ * surfaces, smoothing groups are either turned on or off; there is no difference between values greater
+ * than 0."
+ */
+ if ( result.length > 1 ) {
+
+ var value = result[ 1 ].trim().toLowerCase();
+ state.object.smooth = ( value !== '0' && value !== 'off' );
+
+ } else {
+
+ // ZBrush can produce "s" lines #11707
+ state.object.smooth = true;
+
+ }
+ var material = state.object.currentMaterial();
+ if ( material ) material.smooth = state.object.smooth;
+
+ } else {
+
+ // Handle null terminated files without exception
+ if ( line === '\0' ) continue;
+
+ throw new Error( 'THREE.OBJLoader: Unexpected line: "' + line + '"' );
+
+ }
+
+ }
+
+ state.finalize();
+
+ var container = new THREE.Group();
+ container.materialLibraries = [].concat( state.materialLibraries );
+
+ for ( var i = 0, l = state.objects.length; i < l; i ++ ) {
+
+ var object = state.objects[ i ];
+ var geometry = object.geometry;
+ var materials = object.materials;
+ var isLine = ( geometry.type === 'Line' );
+
+ // Skip o/g line declarations that did not follow with any faces
+ if ( geometry.vertices.length === 0 ) continue;
+
+ var buffergeometry = new THREE.BufferGeometry();
+
+ buffergeometry.addAttribute( 'position', new THREE.Float32BufferAttribute( geometry.vertices, 3 ) );
+
+ if ( geometry.normals.length > 0 ) {
+
+ buffergeometry.addAttribute( 'normal', new THREE.Float32BufferAttribute( geometry.normals, 3 ) );
+
+ } else {
+
+ buffergeometry.computeVertexNormals();
+
+ }
+
+ if ( geometry.colors.length > 0 ) {
+
+ buffergeometry.addAttribute( 'color', new THREE.Float32BufferAttribute( geometry.colors, 3 ) );
+
+ }
+
+ if ( geometry.uvs.length > 0 ) {
+
+ buffergeometry.addAttribute( 'uv', new THREE.Float32BufferAttribute( geometry.uvs, 2 ) );
+
+ }
+
+ // Create materials
+
+ var createdMaterials = [];
+
+ for ( var mi = 0, miLen = materials.length; mi < miLen; mi ++ ) {
+
+ var sourceMaterial = materials[ mi ];
+ var material = undefined;
+
+ if ( this.materials !== null ) {
+
+ material = this.materials.create( sourceMaterial.name );
+
+ // mtl etc. loaders probably can't create line materials correctly, copy properties to a line material.
+ if ( isLine && material && ! ( material instanceof THREE.LineBasicMaterial ) ) {
+
+ var materialLine = new THREE.LineBasicMaterial();
+ materialLine.copy( material );
+ material = materialLine;
+
+ }
+
+ }
+
+ if ( ! material ) {
+
+ material = ( ! isLine ? new THREE.MeshPhongMaterial() : new THREE.LineBasicMaterial() );
+ material.name = sourceMaterial.name;
+
+ }
+
+ material.flatShading = sourceMaterial.smooth ? false : true;
+
+ createdMaterials.push( material );
+
+ }
+
+ // Create mesh
+
+ var mesh;
+
+ if ( createdMaterials.length > 1 ) {
+
+ for ( var mi = 0, miLen = materials.length; mi < miLen; mi ++ ) {
+
+ var sourceMaterial = materials[ mi ];
+ buffergeometry.addGroup( sourceMaterial.groupStart, sourceMaterial.groupCount, mi );
+
+ }
+
+ mesh = ( ! isLine ? new THREE.Mesh( buffergeometry, createdMaterials ) : new THREE.LineSegments( buffergeometry, createdMaterials ) );
+
+ } else {
+
+ mesh = ( ! isLine ? new THREE.Mesh( buffergeometry, createdMaterials[ 0 ] ) : new THREE.LineSegments( buffergeometry, createdMaterials[ 0 ] ) );
+
+ }
+
+ mesh.name = object.name;
+
+ container.add( mesh );
+
+ }
+
+ console.timeEnd( 'OBJLoader' );
+
+ return container;
+
+ }
+
+ };
+
+ return OBJLoader;
+
+} )();
diff --git a/solar/js/libs/dat.gui.min.js b/solar/js/libs/dat.gui.min.js
new file mode 100644
index 0000000..5b69be5
--- /dev/null
+++ b/solar/js/libs/dat.gui.min.js
@@ -0,0 +1,14 @@
+/**
+ * dat-gui JavaScript Controller Library
+ * https://github.com/dataarts/dat.gui
+ *
+ * Copyright 2016 Data Arts Team, Google Creative Lab
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.dat=t():e.dat=t()}(this,function(){return function(e){function t(o){if(n[o])return n[o].exports;var i=n[o]={exports:{},id:o,loaded:!1};return e[o].call(i.exports,i,i.exports,t),i.loaded=!0,i.exports}var n={};return t.m=e,t.c=n,t.p="",t(0)}([function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}var i=n(1),r=o(i);e.exports=r["default"]},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}t.__esModule=!0;var i=n(2),r=o(i),a=n(6),l=o(a),s=n(3),u=o(s),d=n(7),c=o(d),f=n(8),_=o(f),p=n(10),h=o(p),m=n(11),b=o(m),g=n(12),v=o(g),y=n(13),w=o(y),x=n(14),E=o(x),C=n(15),A=o(C),S=n(16),k=o(S),O=n(9),T=o(O),R=n(17),L=o(R);t["default"]={color:{Color:r["default"],math:l["default"],interpret:u["default"]},controllers:{Controller:c["default"],BooleanController:_["default"],OptionController:h["default"],StringController:b["default"],NumberController:v["default"],NumberControllerBox:w["default"],NumberControllerSlider:E["default"],FunctionController:A["default"],ColorController:k["default"]},dom:{dom:T["default"]},gui:{GUI:L["default"]},GUI:L["default"]}},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t,n){Object.defineProperty(e,t,{get:function(){return"RGB"===this.__state.space?this.__state[t]:(h.recalculateRGB(this,t,n),this.__state[t])},set:function(e){"RGB"!==this.__state.space&&(h.recalculateRGB(this,t,n),this.__state.space="RGB"),this.__state[t]=e}})}function a(e,t){Object.defineProperty(e,t,{get:function(){return"HSV"===this.__state.space?this.__state[t]:(h.recalculateHSV(this),this.__state[t])},set:function(e){"HSV"!==this.__state.space&&(h.recalculateHSV(this),this.__state.space="HSV"),this.__state[t]=e}})}t.__esModule=!0;var l=n(3),s=o(l),u=n(6),d=o(u),c=n(4),f=o(c),_=n(5),p=o(_),h=function(){function e(){if(i(this,e),this.__state=s["default"].apply(this,arguments),this.__state===!1)throw new Error("Failed to interpret color arguments");this.__state.a=this.__state.a||1}return e.prototype.toString=function(){return(0,f["default"])(this)},e.prototype.toHexString=function(){return(0,f["default"])(this,!0)},e.prototype.toOriginal=function(){return this.__state.conversion.write(this)},e}();h.recalculateRGB=function(e,t,n){if("HEX"===e.__state.space)e.__state[t]=d["default"].component_from_hex(e.__state.hex,n);else{if("HSV"!==e.__state.space)throw new Error("Corrupted color state");p["default"].extend(e.__state,d["default"].hsv_to_rgb(e.__state.h,e.__state.s,e.__state.v))}},h.recalculateHSV=function(e){var t=d["default"].rgb_to_hsv(e.r,e.g,e.b);p["default"].extend(e.__state,{s:t.s,v:t.v}),p["default"].isNaN(t.h)?p["default"].isUndefined(e.__state.h)&&(e.__state.h=0):e.__state.h=t.h},h.COMPONENTS=["r","g","b","h","s","v","hex","a"],r(h.prototype,"r",2),r(h.prototype,"g",1),r(h.prototype,"b",0),a(h.prototype,"h"),a(h.prototype,"s"),a(h.prototype,"v"),Object.defineProperty(h.prototype,"a",{get:function(){return this.__state.a},set:function(e){this.__state.a=e}}),Object.defineProperty(h.prototype,"hex",{get:function(){return"HEX"!==!this.__state.space&&(this.__state.hex=d["default"].rgb_to_hex(this.r,this.g,this.b)),this.__state.hex},set:function(e){this.__state.space="HEX",this.__state.hex=e}}),t["default"]=h},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}t.__esModule=!0;var i=n(4),r=o(i),a=n(5),l=o(a),s=[{litmus:l["default"].isString,conversions:{THREE_CHAR_HEX:{read:function(e){var t=e.match(/^#([A-F0-9])([A-F0-9])([A-F0-9])$/i);return null!==t&&{space:"HEX",hex:parseInt("0x"+t[1].toString()+t[1].toString()+t[2].toString()+t[2].toString()+t[3].toString()+t[3].toString(),0)}},write:r["default"]},SIX_CHAR_HEX:{read:function(e){var t=e.match(/^#([A-F0-9]{6})$/i);return null!==t&&{space:"HEX",hex:parseInt("0x"+t[1].toString(),0)}},write:r["default"]},CSS_RGB:{read:function(e){var t=e.match(/^rgb\(\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*\)/);return null!==t&&{space:"RGB",r:parseFloat(t[1]),g:parseFloat(t[2]),b:parseFloat(t[3])}},write:r["default"]},CSS_RGBA:{read:function(e){var t=e.match(/^rgba\(\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*,\s*(.+)\s*\)/);return null!==t&&{space:"RGB",r:parseFloat(t[1]),g:parseFloat(t[2]),b:parseFloat(t[3]),a:parseFloat(t[4])}},write:r["default"]}}},{litmus:l["default"].isNumber,conversions:{HEX:{read:function(e){return{space:"HEX",hex:e,conversionName:"HEX"}},write:function(e){return e.hex}}}},{litmus:l["default"].isArray,conversions:{RGB_ARRAY:{read:function(e){return 3===e.length&&{space:"RGB",r:e[0],g:e[1],b:e[2]}},write:function(e){return[e.r,e.g,e.b]}},RGBA_ARRAY:{read:function(e){return 4===e.length&&{space:"RGB",r:e[0],g:e[1],b:e[2],a:e[3]}},write:function(e){return[e.r,e.g,e.b,e.a]}}}},{litmus:l["default"].isObject,conversions:{RGBA_OBJ:{read:function(e){return!!(l["default"].isNumber(e.r)&&l["default"].isNumber(e.g)&&l["default"].isNumber(e.b)&&l["default"].isNumber(e.a))&&{space:"RGB",r:e.r,g:e.g,b:e.b,a:e.a}},write:function(e){return{r:e.r,g:e.g,b:e.b,a:e.a}}},RGB_OBJ:{read:function(e){return!!(l["default"].isNumber(e.r)&&l["default"].isNumber(e.g)&&l["default"].isNumber(e.b))&&{space:"RGB",r:e.r,g:e.g,b:e.b}},write:function(e){return{r:e.r,g:e.g,b:e.b}}},HSVA_OBJ:{read:function(e){return!!(l["default"].isNumber(e.h)&&l["default"].isNumber(e.s)&&l["default"].isNumber(e.v)&&l["default"].isNumber(e.a))&&{space:"HSV",h:e.h,s:e.s,v:e.v,a:e.a}},write:function(e){return{h:e.h,s:e.s,v:e.v,a:e.a}}},HSV_OBJ:{read:function(e){return!!(l["default"].isNumber(e.h)&&l["default"].isNumber(e.s)&&l["default"].isNumber(e.v))&&{space:"HSV",h:e.h,s:e.s,v:e.v}},write:function(e){return{h:e.h,s:e.s,v:e.v}}}}}],u=void 0,d=void 0,c=function(){d=!1;var e=arguments.length>1?l["default"].toArray(arguments):arguments[0];return l["default"].each(s,function(t){if(t.litmus(e))return l["default"].each(t.conversions,function(t,n){if(u=t.read(e),d===!1&&u!==!1)return d=u,u.conversionName=n,u.conversion=t,l["default"].BREAK}),l["default"].BREAK}),d};t["default"]=c},function(e,t){"use strict";t.__esModule=!0,t["default"]=function(e,t){var n=e.__state.conversionName.toString(),o=Math.round(e.r),i=Math.round(e.g),r=Math.round(e.b),a=e.a,l=Math.round(e.h),s=e.s.toFixed(1),u=e.v.toFixed(1);if(t||"THREE_CHAR_HEX"===n||"SIX_CHAR_HEX"===n){for(var d=e.hex.toString(16);d.length<6;)d="0"+d;return"#"+d}return"CSS_RGB"===n?"rgb("+o+","+i+","+r+")":"CSS_RGBA"===n?"rgba("+o+","+i+","+r+","+a+")":"HEX"===n?"0x"+e.hex.toString(16):"RGB_ARRAY"===n?"["+o+","+i+","+r+"]":"RGBA_ARRAY"===n?"["+o+","+i+","+r+","+a+"]":"RGB_OBJ"===n?"{r:"+o+",g:"+i+",b:"+r+"}":"RGBA_OBJ"===n?"{r:"+o+",g:"+i+",b:"+r+",a:"+a+"}":"HSV_OBJ"===n?"{h:"+l+",s:"+s+",v:"+u+"}":"HSVA_OBJ"===n?"{h:"+l+",s:"+s+",v:"+u+",a:"+a+"}":"unknown format"}},function(e,t){"use strict";t.__esModule=!0;var n=Array.prototype.forEach,o=Array.prototype.slice,i={BREAK:{},extend:function(e){return this.each(o.call(arguments,1),function(t){var n=this.isObject(t)?Object.keys(t):[];n.forEach(function(n){this.isUndefined(t[n])||(e[n]=t[n])}.bind(this))},this),e},defaults:function(e){return this.each(o.call(arguments,1),function(t){var n=this.isObject(t)?Object.keys(t):[];n.forEach(function(n){this.isUndefined(e[n])&&(e[n]=t[n])}.bind(this))},this),e},compose:function(){var e=o.call(arguments);return function(){for(var t=o.call(arguments),n=e.length-1;n>=0;n--)t=[e[n].apply(this,t)];return t[0]}},each:function(e,t,o){if(e)if(n&&e.forEach&&e.forEach===n)e.forEach(t,o);else if(e.length===e.length+0){var i=void 0,r=void 0;for(i=0,r=e.length;i>8*t&255},hex_with_component:function(e,t,o){return o<<(n=8*t)|e&~(255<-1?t.length-t.indexOf(".")-1:0}t.__esModule=!0;var s=n(7),u=o(s),d=n(5),c=o(d),f=function(e){function t(n,o,a){i(this,t);var s=r(this,e.call(this,n,o)),u=a||{};return s.__min=u.min,s.__max=u.max,s.__step=u.step,c["default"].isUndefined(s.__step)?0===s.initialValue?s.__impliedStep=1:s.__impliedStep=Math.pow(10,Math.floor(Math.log(Math.abs(s.initialValue))/Math.LN10))/10:s.__impliedStep=s.__step,s.__precision=l(s.__impliedStep),s}return a(t,e),t.prototype.setValue=function(t){var n=t;return void 0!==this.__min&&nthis.__max&&(n=this.__max),void 0!==this.__step&&n%this.__step!==0&&(n=Math.round(n/this.__step)*this.__step),e.prototype.setValue.call(this,n)},t.prototype.min=function(e){return this.__min=e,this},t.prototype.max=function(e){return this.__max=e,this},t.prototype.step=function(e){return this.__step=e,this.__impliedStep=e,this.__precision=l(e),this},t}(u["default"]);t["default"]=f},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function l(e,t){var n=Math.pow(10,t);return Math.round(e*n)/n}t.__esModule=!0;var s=n(12),u=o(s),d=n(9),c=o(d),f=n(5),_=o(f),p=function(e){function t(n,o,a){function l(){var e=parseFloat(m.__input.value);_["default"].isNaN(e)||m.setValue(e)}function s(){m.__onFinishChange&&m.__onFinishChange.call(m,m.getValue())}function u(){s()}function d(e){var t=b-e.clientY;m.setValue(m.getValue()+t*m.__impliedStep),b=e.clientY}function f(){c["default"].unbind(window,"mousemove",d),c["default"].unbind(window,"mouseup",f),s()}function p(e){c["default"].bind(window,"mousemove",d),c["default"].bind(window,"mouseup",f),b=e.clientY}i(this,t);var h=r(this,e.call(this,n,o,a));h.__truncationSuspended=!1;var m=h,b=void 0;return h.__input=document.createElement("input"),h.__input.setAttribute("type","text"),c["default"].bind(h.__input,"change",l),c["default"].bind(h.__input,"blur",u),c["default"].bind(h.__input,"mousedown",p),c["default"].bind(h.__input,"keydown",function(e){13===e.keyCode&&(m.__truncationSuspended=!0,this.blur(),m.__truncationSuspended=!1,s())}),h.updateDisplay(),h.domElement.appendChild(h.__input),h}return a(t,e),t.prototype.updateDisplay=function(){return this.__input.value=this.__truncationSuspended?this.getValue():l(this.getValue(),this.__precision),e.prototype.updateDisplay.call(this)},t}(u["default"]);t["default"]=p},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function l(e,t,n,o,i){return o+(i-o)*((e-t)/(n-t))}t.__esModule=!0;var s=n(12),u=o(s),d=n(9),c=o(d),f=function(e){function t(n,o,a,s,u){function d(e){document.activeElement.blur(),c["default"].bind(window,"mousemove",f),c["default"].bind(window,"mouseup",_),f(e)}function f(e){e.preventDefault();var t=h.__background.getBoundingClientRect();return h.setValue(l(e.clientX,t.left,t.right,h.__min,h.__max)),!1}function _(){c["default"].unbind(window,"mousemove",f),c["default"].unbind(window,"mouseup",_),h.__onFinishChange&&h.__onFinishChange.call(h,h.getValue())}i(this,t);var p=r(this,e.call(this,n,o,{min:a,max:s,step:u})),h=p;return p.__background=document.createElement("div"),p.__foreground=document.createElement("div"),c["default"].bind(p.__background,"mousedown",d),c["default"].addClass(p.__background,"slider"),c["default"].addClass(p.__foreground,"slider-fg"),p.updateDisplay(),p.__background.appendChild(p.__foreground),p.domElement.appendChild(p.__background),p}return a(t,e),t.prototype.updateDisplay=function(){var t=(this.getValue()-this.__min)/(this.__max-this.__min);return this.__foreground.style.width=100*t+"%",e.prototype.updateDisplay.call(this)},t}(u["default"]);t["default"]=f},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}t.__esModule=!0;var l=n(7),s=o(l),u=n(9),d=o(u),c=function(e){function t(n,o,a){i(this,t);var l=r(this,e.call(this,n,o)),s=l;return l.__button=document.createElement("div"),l.__button.innerHTML=void 0===a?"Fire":a,d["default"].bind(l.__button,"click",function(e){return e.preventDefault(),s.fire(),!1}),d["default"].addClass(l.__button,"button"),l.domElement.appendChild(l.__button),l}return a(t,e),t.prototype.fire=function(){this.__onChange&&this.__onChange.call(this),this.getValue().call(this.object),this.__onFinishChange&&this.__onFinishChange.call(this,this.getValue())},t}(s["default"]);t["default"]=c},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function r(e,t){if(!e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return!t||"object"!=typeof t&&"function"!=typeof t?e:t}function a(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function, not "+typeof t);e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}}),t&&(Object.setPrototypeOf?Object.setPrototypeOf(e,t):e.__proto__=t)}function l(e,t,n,o){e.style.background="",g["default"].each(y,function(i){e.style.cssText+="background: "+i+"linear-gradient("+t+", "+n+" 0%, "+o+" 100%); "})}function s(e){e.style.background="",e.style.cssText+="background: -moz-linear-gradient(top, #ff0000 0%, #ff00ff 17%, #0000ff 34%, #00ffff 50%, #00ff00 67%, #ffff00 84%, #ff0000 100%);",e.style.cssText+="background: -webkit-linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText+="background: -o-linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText+="background: -ms-linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);",e.style.cssText+="background: linear-gradient(top, #ff0000 0%,#ff00ff 17%,#0000ff 34%,#00ffff 50%,#00ff00 67%,#ffff00 84%,#ff0000 100%);"}t.__esModule=!0;var u=n(7),d=o(u),c=n(9),f=o(c),_=n(2),p=o(_),h=n(3),m=o(h),b=n(5),g=o(b),v=function(e){function t(n,o){function a(e){h(e),f["default"].bind(window,"mousemove",h),f["default"].bind(window,"mouseup",u)}function u(){f["default"].unbind(window,"mousemove",h),f["default"].unbind(window,"mouseup",u),_()}function d(){var e=(0,m["default"])(this.value);e!==!1?(y.__color.__state=e,y.setValue(y.__color.toOriginal())):this.value=y.__color.toString()}function c(){f["default"].unbind(window,"mousemove",b),f["default"].unbind(window,"mouseup",c),_()}function _(){y.__onFinishChange&&y.__onFinishChange.call(y,y.__color.toOriginal())}function h(e){e.preventDefault();var t=y.__saturation_field.getBoundingClientRect(),n=(e.clientX-t.left)/(t.right-t.left),o=1-(e.clientY-t.top)/(t.bottom-t.top);return o>1?o=1:o<0&&(o=0),n>1?n=1:n<0&&(n=0),y.__color.v=o,y.__color.s=n,y.setValue(y.__color.toOriginal()),!1}function b(e){e.preventDefault();var t=y.__hue_field.getBoundingClientRect(),n=1-(e.clientY-t.top)/(t.bottom-t.top);return n>1?n=1:n<0&&(n=0),y.__color.h=360*n,y.setValue(y.__color.toOriginal()),!1}i(this,t);var v=r(this,e.call(this,n,o));v.__color=new p["default"](v.getValue()),v.__temp=new p["default"](0);var y=v;v.domElement=document.createElement("div"),f["default"].makeSelectable(v.domElement,!1),v.__selector=document.createElement("div"),v.__selector.className="selector",v.__saturation_field=document.createElement("div"),v.__saturation_field.className="saturation-field",v.__field_knob=document.createElement("div"),v.__field_knob.className="field-knob",v.__field_knob_border="2px solid ",v.__hue_knob=document.createElement("div"),v.__hue_knob.className="hue-knob",v.__hue_field=document.createElement("div"),v.__hue_field.className="hue-field",v.__input=document.createElement("input"),v.__input.type="text",v.__input_textShadow="0 1px 1px ",f["default"].bind(v.__input,"keydown",function(e){13===e.keyCode&&d.call(this)}),f["default"].bind(v.__input,"blur",d),f["default"].bind(v.__selector,"mousedown",function(){f["default"].addClass(this,"drag").bind(window,"mouseup",function(){f["default"].removeClass(y.__selector,"drag")})});var w=document.createElement("div");return g["default"].extend(v.__selector.style,{width:"122px",height:"102px",padding:"3px",backgroundColor:"#222",boxShadow:"0px 1px 3px rgba(0,0,0,0.3)"}),g["default"].extend(v.__field_knob.style,{position:"absolute",width:"12px",height:"12px",border:v.__field_knob_border+(v.__color.v<.5?"#fff":"#000"),boxShadow:"0px 1px 3px rgba(0,0,0,0.5)",borderRadius:"12px",zIndex:1}),g["default"].extend(v.__hue_knob.style,{position:"absolute",width:"15px",height:"2px",borderRight:"4px solid #fff",zIndex:1}),g["default"].extend(v.__saturation_field.style,{width:"100px",height:"100px",border:"1px solid #555",marginRight:"3px",display:"inline-block",cursor:"pointer"}),g["default"].extend(w.style,{width:"100%",height:"100%",background:"none"}),l(w,"top","rgba(0,0,0,0)","#000"),g["default"].extend(v.__hue_field.style,{width:"15px",height:"100px",border:"1px solid #555",cursor:"ns-resize",position:"absolute",top:"3px",right:"3px"}),s(v.__hue_field),g["default"].extend(v.__input.style,{outline:"none",textAlign:"center",color:"#fff",border:0,fontWeight:"bold",textShadow:v.__input_textShadow+"rgba(0,0,0,0.7)"}),f["default"].bind(v.__saturation_field,"mousedown",a),f["default"].bind(v.__field_knob,"mousedown",a),f["default"].bind(v.__hue_field,"mousedown",function(e){b(e),f["default"].bind(window,"mousemove",b),f["default"].bind(window,"mouseup",c)}),v.__saturation_field.appendChild(w),v.__selector.appendChild(v.__field_knob),v.__selector.appendChild(v.__saturation_field),v.__selector.appendChild(v.__hue_field),v.__hue_field.appendChild(v.__hue_knob),v.domElement.appendChild(v.__input),v.domElement.appendChild(v.__selector),v.updateDisplay(),v}return a(t,e),t.prototype.updateDisplay=function(){var e=(0,m["default"])(this.getValue());if(e!==!1){var t=!1;g["default"].each(p["default"].COMPONENTS,function(n){if(!g["default"].isUndefined(e[n])&&!g["default"].isUndefined(this.__color.__state[n])&&e[n]!==this.__color.__state[n])return t=!0,{}},this),t&&g["default"].extend(this.__color.__state,e)}g["default"].extend(this.__temp.__state,this.__color.__state),this.__temp.a=1;var n=this.__color.v<.5||this.__color.s>.5?255:0,o=255-n;g["default"].extend(this.__field_knob.style,{marginLeft:100*this.__color.s-7+"px",marginTop:100*(1-this.__color.v)-7+"px",backgroundColor:this.__temp.toHexString(),border:this.__field_knob_border+"rgb("+n+","+n+","+n+")"}),this.__hue_knob.style.marginTop=100*(1-this.__color.h/360)+"px",this.__temp.s=1,this.__temp.v=1,l(this.__saturation_field,"left","#fff",this.__temp.toHexString()),this.__input.value=this.__color.toString(),g["default"].extend(this.__input.style,{backgroundColor:this.__color.toHexString(),color:"rgb("+n+","+n+","+n+")",textShadow:this.__input_textShadow+"rgba("+o+","+o+","+o+",.7)"})},t}(d["default"]),y=["-moz-","-o-","-webkit-","-ms-",""];t["default"]=v},function(e,t,n){"use strict";function o(e){return e&&e.__esModule?e:{"default":e}}function i(e,t,n){var o=document.createElement("li");return t&&o.appendChild(t),n?e.__ul.insertBefore(o,n):e.__ul.appendChild(o),e.onResize(),o}function r(e,t){var n=e.__preset_select[e.__preset_select.selectedIndex];t?n.innerHTML=n.value+"*":n.innerHTML=n.value}function a(e,t,n){if(n.__li=t,n.__gui=e,U["default"].extend(n,{options:function(t){if(arguments.length>1){var o=n.__li.nextElementSibling;return n.remove(),s(e,n.object,n.property,{before:o,factoryArgs:[U["default"].toArray(arguments)]})}if(U["default"].isArray(t)||U["default"].isObject(t)){var i=n.__li.nextElementSibling;return n.remove(),s(e,n.object,n.property,{before:i,factoryArgs:[t]})}},name:function(e){return n.__li.firstElementChild.firstElementChild.innerHTML=e,n},listen:function(){return n.__gui.listen(n),n},remove:function(){
+return n.__gui.remove(n),n}}),n instanceof B["default"])!function(){var e=new N["default"](n.object,n.property,{min:n.__min,max:n.__max,step:n.__step});U["default"].each(["updateDisplay","onChange","onFinishChange","step"],function(t){var o=n[t],i=e[t];n[t]=e[t]=function(){var t=Array.prototype.slice.call(arguments);return i.apply(e,t),o.apply(n,t)}}),z["default"].addClass(t,"has-slider"),n.domElement.insertBefore(e.domElement,n.domElement.firstElementChild)}();else if(n instanceof N["default"]){var o=function(t){if(U["default"].isNumber(n.__min)&&U["default"].isNumber(n.__max)){var o=n.__li.firstElementChild.firstElementChild.innerHTML,i=n.__gui.__listening.indexOf(n)>-1;n.remove();var r=s(e,n.object,n.property,{before:n.__li.nextElementSibling,factoryArgs:[n.__min,n.__max,n.__step]});return r.name(o),i&&r.listen(),r}return t};n.min=U["default"].compose(o,n.min),n.max=U["default"].compose(o,n.max)}else n instanceof O["default"]?(z["default"].bind(t,"click",function(){z["default"].fakeEvent(n.__checkbox,"click")}),z["default"].bind(n.__checkbox,"click",function(e){e.stopPropagation()})):n instanceof R["default"]?(z["default"].bind(t,"click",function(){z["default"].fakeEvent(n.__button,"click")}),z["default"].bind(t,"mouseover",function(){z["default"].addClass(n.__button,"hover")}),z["default"].bind(t,"mouseout",function(){z["default"].removeClass(n.__button,"hover")})):n instanceof j["default"]&&(z["default"].addClass(t,"color"),n.updateDisplay=U["default"].compose(function(e){return t.style.borderLeftColor=n.__color.toString(),e},n.updateDisplay),n.updateDisplay());n.setValue=U["default"].compose(function(t){return e.getRoot().__preset_select&&n.isModified()&&r(e.getRoot(),!0),t},n.setValue)}function l(e,t){var n=e.getRoot(),o=n.__rememberedObjects.indexOf(t.object);if(o!==-1){var i=n.__rememberedObjectIndecesToControllers[o];if(void 0===i&&(i={},n.__rememberedObjectIndecesToControllers[o]=i),i[t.property]=t,n.load&&n.load.remembered){var r=n.load.remembered,a=void 0;if(r[e.preset])a=r[e.preset];else{if(!r[Q])return;a=r[Q]}if(a[o]&&void 0!==a[o][t.property]){var l=a[o][t.property];t.initialValue=l,t.setValue(l)}}}}function s(e,t,n,o){if(void 0===t[n])throw new Error('Object "'+t+'" has no property "'+n+'"');var r=void 0;if(o.color)r=new j["default"](t,n);else{var s=[t,n].concat(o.factoryArgs);r=C["default"].apply(e,s)}o.before instanceof S["default"]&&(o.before=o.before.__li),l(e,r),z["default"].addClass(r.domElement,"c");var u=document.createElement("span");z["default"].addClass(u,"property-name"),u.innerHTML=r.property;var d=document.createElement("div");d.appendChild(u),d.appendChild(r.domElement);var c=i(e,d,o.before);return z["default"].addClass(c,oe.CLASS_CONTROLLER_ROW),r instanceof j["default"]?z["default"].addClass(c,"color"):z["default"].addClass(c,g(r.getValue())),a(e,c,r),e.__controllers.push(r),r}function u(e,t){return document.location.href+"."+t}function d(e,t,n){var o=document.createElement("option");o.innerHTML=t,o.value=t,e.__preset_select.appendChild(o),n&&(e.__preset_select.selectedIndex=e.__preset_select.length-1)}function c(e,t){t.style.display=e.useLocalStorage?"block":"none"}function f(e){var t=e.__save_row=document.createElement("li");z["default"].addClass(e.domElement,"has-save"),e.__ul.insertBefore(t,e.__ul.firstChild),z["default"].addClass(t,"save-row");var n=document.createElement("span");n.innerHTML=" ",z["default"].addClass(n,"button gears");var o=document.createElement("span");o.innerHTML="Save",z["default"].addClass(o,"button"),z["default"].addClass(o,"save");var i=document.createElement("span");i.innerHTML="New",z["default"].addClass(i,"button"),z["default"].addClass(i,"save-as");var r=document.createElement("span");r.innerHTML="Revert",z["default"].addClass(r,"button"),z["default"].addClass(r,"revert");var a=e.__preset_select=document.createElement("select");e.load&&e.load.remembered?U["default"].each(e.load.remembered,function(t,n){d(e,n,n===e.preset)}):d(e,Q,!1),z["default"].bind(a,"change",function(){for(var t=0;t0&&(e.preset=this.preset,e.remembered||(e.remembered={}),e.remembered[this.preset]=h(this)),e.folders={},U["default"].each(this.__folders,function(t,n){e.folders[n]=t.getSaveObject()}),e},save:function(){this.load.remembered||(this.load.remembered={}),this.load.remembered[this.preset]=h(this),r(this,!1),this.saveToLocalStorageIfPossible()},saveAs:function(e){this.load.remembered||(this.load.remembered={},this.load.remembered[Q]=h(this,!0)),this.load.remembered[e]=h(this),this.preset=e,d(this,e,!0),this.saveToLocalStorageIfPossible()},revert:function(e){U["default"].each(this.__controllers,function(t){this.getRoot().load.remembered?l(e||this.getRoot(),t):t.setValue(t.initialValue),t.__onFinishChange&&t.__onFinishChange.call(t,t.getValue())},this),U["default"].each(this.__folders,function(e){e.revert(e)}),e||r(this.getRoot(),!1)},listen:function(e){var t=0===this.__listening.length;this.__listening.push(e),t&&b(this.__listening)},updateDisplay:function(){U["default"].each(this.__controllers,function(e){e.updateDisplay()}),U["default"].each(this.__folders,function(e){e.updateDisplay()})}}),e.exports=oe},function(e,t){"use strict";e.exports={load:function(e,t){var n=t||document,o=n.createElement("link");o.type="text/css",o.rel="stylesheet",o.href=e,n.getElementsByTagName("head")[0].appendChild(o)},inject:function(e,t){var n=t||document,o=document.createElement("style");o.type="text/css",o.innerHTML=e;var i=n.getElementsByTagName("head")[0];try{i.appendChild(o)}catch(r){}}}},function(e,t){e.exports=" Here's the new load parameter for your
GUI's constructor:
Automatically save values to
localStorage on exit.
The values saved to localStorage will override those passed to dat.GUI's constructor. This makes it easier to work incrementally, but localStorage is fragile, and your friends may not see the same values you do.
ai `star`
- [particles.js](https://github.com/VincentGarreau/particles.js)
+- [galaxy](https://github.com/the-halfbloodprince/GalaxyM1199)
+- [solar-sys](https://github.com/solarcg/SolarSys)
+
+## example
+
+- [galaxy2](https://github.com/the-halfbloodprince/Galaxy-M2999)
+- [100-stars](https://stars.chromeexperiments.com/)
+- [nasa/solar-system](https://eyes.nasa.gov/apps/solar-system/)
+- [nasa/3d-resources](https://github.com/nasa/NASA-3D-Resources)
diff --git a/solar/css/solar.css b/solar/css/solar.css
new file mode 100644
index 0000000..afad1d0
--- /dev/null
+++ b/solar/css/solar.css
@@ -0,0 +1,175 @@
+body {
+ color: #ffffff;
+ font-family: "Segoe UI", Myriad, Helvetica, Arial, "DejaVu Sans", "Noto Sans CJK SC", "Source Han Sans SC";
+ font-size: 20px;
+ text-align: left;
+ background-color: #000000;
+ margin: 0px;
+ overflow: hidden;
+}
+
+.small {
+ font-size: 12px;
+}
+
+#container {
+ text-align: center;
+ width: 100%;
+ height: 100%;
+}
+
+#info {
+ text-align: center;
+ position: absolute;
+ top: 0px;
+ width: 100%;
+ padding: 5px;
+}
+
+h3, p {
+ margin-top: 5px;
+ margin-bottom: 5px;
+}
+
+img {
+ margin-top: 10px;
+ max-width:100% !important;
+ height:30% !important;
+}
+
+
+a {
+ color: #ffffff;
+ outline: none;
+ text-decoration: none;
+}
+
+a:hover, a:focus {
+ color: #ffffff;
+}
+
+.progress {
+ display: inline-block;
+ font-size: 18px;
+ color: #ffffff !important;
+ text-decoration: none !important;
+ margin-top: 20px;
+ padding: 6px 70px;
+ line-height: 1;
+ overflow: hidden;
+ position: relative;
+
+ border-style: solid;
+ border-width: 1px;
+ border-color: #ffffff;
+ border-radius: 15px;
+
+ background-color: transparent;
+
+ transition: box-shadow 0.5s;
+ -moz-transition: box-shadow 0.5s;
+ -o-transition: box-shadow 0.5s;
+ -webkit-transition: box-shadow 0.5s;
+}
+
+.progress:hover, .progress:focus {
+ box-shadow: 0px 0px 30px #ffffffaa;
+ transition: box-shadow 0.5s;
+ -moz-transition: box-shadow 0.5s;
+ -o-transition: box-shadow 0.5s;
+ -webkit-transition: box-shadow 0.5s;
+}
+
+.progress.in-progress,
+.progress.finished {
+ color: transparent !important;
+}
+
+.progress.in-progress:after,
+.progress.finished:after {
+ position: absolute;
+ z-index: 2;
+ width: 100%;
+ height: 100%;
+ text-align: center;
+ top: 0;
+ padding-top: inherit;
+ color: #000000 !important;
+ left: 0;
+}
+
+/* If the .in-progress class is set on the button, show the
+ contents of the data-loading attribute on the butotn */
+
+.progress.in-progress:after {
+ content: attr(data-loading);
+}
+
+/* The same goes for the .finished class */
+
+.progress.finished:after {
+ content: attr(data-finished);
+}
+
+/* The colorful bar that grows depending on the progress */
+
+.progress .tz-bar {
+ background-color: #ffffff;
+ height: 3px;
+ bottom: 0;
+ left: 0;
+ width: 0;
+ position: absolute;
+ z-index: 1;
+
+ border-radius: 0 0 2px 2px;
+
+ -webkit-transition: width 0.5s, height 0.5s;
+ -moz-transition: width 0.5s, height 0.5s;
+ transition: width 0.5s, height 0.5s;
+}
+
+/* The bar can be either horizontal, or vertical */
+
+.progress .tz-bar.background-horizontal {
+ height: 100%;
+ border-radius: 2px;
+}
+
+.progress .tz-bar.background-vertical {
+ height: 0;
+ top: 0;
+ width: 100%;
+ border-radius: 2px;
+}
+
+/*----------------------------
+ Color themes
+-----------------------------*/
+
+.progress.red {
+ background-color: #e6537d;
+ background-image: -webkit-linear-gradient(top, #e6537d, #df5179);
+ background-image: -moz-linear-gradient(top, #e6537d, #df5179);
+ background-image: linear-gradient(top, #e6537d, #df5179);
+}
+
+.progress.red .tz-bar {
+ background-color: #6876b4;
+}
+
+.progress.green {
+ background-color: #64c896;
+ background-image: -webkit-linear-gradient(top, #64c896, #5fbd8e);
+ background-image: -moz-linear-gradient(top, #64c896, #5fbd8e);
+ background-image: linear-gradient(top, #64c896, #5fbd8e);
+}
+
+.progress.green .tz-bar {
+ background-color: #9e81d6;
+}
+
+.key-h {
+ text-align: left;
+ padding:0 10px 10px 10px;
+}
diff --git a/solar/images/1.png b/solar/images/1.png
new file mode 100644
index 0000000..af1fbed
Binary files /dev/null and b/solar/images/1.png differ
diff --git a/solar/images/2.png b/solar/images/2.png
new file mode 100644
index 0000000..851b05a
Binary files /dev/null and b/solar/images/2.png differ
diff --git a/solar/images/3.png b/solar/images/3.png
new file mode 100644
index 0000000..49e8205
Binary files /dev/null and b/solar/images/3.png differ
diff --git a/solar/images/4.png b/solar/images/4.png
new file mode 100644
index 0000000..4f930ba
Binary files /dev/null and b/solar/images/4.png differ
diff --git a/solar/images/5.png b/solar/images/5.png
new file mode 100644
index 0000000..d1ed8c0
Binary files /dev/null and b/solar/images/5.png differ
diff --git a/solar/images/6.png b/solar/images/6.png
new file mode 100644
index 0000000..33d07de
Binary files /dev/null and b/solar/images/6.png differ
diff --git a/solar/index.html b/solar/index.html
new file mode 100644
index 0000000..369be74
--- /dev/null
+++ b/solar/index.html
@@ -0,0 +1,70 @@
+
+
+
+