var scene, camera, renderer, loader;
            var spritescene;
            var clouds = new Array();
            var stars = new Array();
            var timer = Date.now();
            var smoke, ambientclouds, movingclouds;

            function SmokeParticles(count)
            {
                var obj = new THREE.Object3D;
                var particles = new Array;
                var num = count;

                var radius = 1.35;

                function CreateParticle(idx, lag)
                {
                    if (!particles[idx])
                    {
                        var material = new THREE.MeshBasicMaterial({
                            map: THREE.ImageUtils.loadTexture('img/cloudsmall.png'),
                            transparent: true,
                        });
                        var geometry = new THREE.PlaneGeometry(1, 1);
                        var particle = new THREE.Mesh( geometry, material );
                        particle.scale.x = particle.scale.y = 1.5;
                        obj.add(particle);

                        particles[idx] = {
                            p: particle,
                            lifetime: 0,
                            angle: 0,
                            phase: 0
                        };

                        lag = true;
                    }

                    if (lag)
                        particles[idx].phase = Math.random()*Math.PI*2;
                    else
                        particles[idx].phase = 0;

                    var angle = Math.random()*Math.PI*2;
                    particles[idx].p.rotation.z = angle+THREE.Math.randFloatSpread(0.2);
                    particles[idx].p.material.opacity = 0;
                    particles[idx].angle = angle;
                    particles[idx].lifetime = 4000+Math.random()*6000;

                }

                for (var i = 0; i < num; ++i)
                {
                    CreateParticle(i);
                }

                this.Update = function(diff)
                {
                    var lag = false;
                    if (diff > 1000)
                        lag = true;
                    for (var i = 0; i < num; ++i)
                    {
                        particles[i].phase += diff/particles[i].lifetime*Math.PI;
                        if (particles[i].phase >= Math.PI*2)
                        {
                            CreateParticle(i, lag);
                        }
                        else
                        {
                            particles[i].p.material.opacity = Math.sin(particles[i].phase)*0.1;
                            var angle = particles[i].angle;
                            var crad = radius + Math.sin(particles[i].phase*0.5)*0.3;
                            particles[i].p.position.x = crad*Math.cos(angle);
                            particles[i].p.position.y = crad*Math.sin(angle);
                        }
                    }
                }

                this.AddToScene = function(scene)
                {
                    obj.position.z = 1.1;
                    scene.add(obj);
                }
            }

            function AmbientClouds(count)
            {
                var obj = new THREE.Object3D;
                var particles = new Array;
                var num = count;

                var speed = 0.00008;

                var material = new THREE.MeshBasicMaterial({
                    map: THREE.ImageUtils.loadTexture('img/ambientclouds.png'),
                    transparent: true,
                    opacity: 0.2
                });

                function CreateParticle(idx)
                {
                    var geometry = new THREE.PlaneGeometry(1, 1);
                    var particle = new THREE.Mesh( geometry, material );
                    particle.position.x = THREE.Math.randFloatSpread(20);
                    particle.position.y = THREE.Math.randFloatSpread(10);
                    particle.scale.x = particle.scale.y = 10;
                    obj.add(particle);

                    particles[idx] = particle;
                }

                for (var i = 0; i < num; ++i)
                {
                    CreateParticle(i);
                }

                this.Update = function(diff)
                {
                    for (var i = 0; i < num; ++i)
                    {
                        particles[i].rotation.z += diff*speed;
                    }
                }

                this.AddToScene = function(scene)
                {
                    obj.position.z = 0.5;
                    scene.add(obj);
                }
            }

            function MovingClouds(count)
            {
                var obj = new THREE.Object3D;
                var particles = new Array;
                var num = count;

                var xlimit = 12;

                var material = new THREE.MeshBasicMaterial({
                    map: THREE.ImageUtils.loadTexture('img/clouds.png'),
                    transparent: true,
                    opacity: 0.2
                });

                function CreateParticle(idx, lag)
                {
                    if (!particles[idx])
                    {
                        var geometry = new THREE.PlaneGeometry(1, 1);
                        var particle = new THREE.Mesh(geometry, material);
                        particle.scale.x = particle.scale.y = 10;
                        obj.add(particle);

                        particles[idx] = {
                            p: particle,
                            speed: 0
                        };

                        lag = true;
                    }

                    if (lag)
                        particles[idx].p.position.x = THREE.Math.randFloatSpread(xlimit*2);
                    else
                        particles[idx].p.position.x = -xlimit;

                    particles[idx].p.position.y = THREE.Math.randFloatSpread(3)-4;
                    particles[idx].speed = (Math.random()+0.2)*0.0003;

                }

                for (var i = 0; i < num; ++i)
                {
                    CreateParticle(i);
                }

                this.Update = function(diff)
                {
                    var lag = false;
                    if (diff > 1000)
                        lag = true;
                    for (var i = 0; i < num; ++i)
                    {
                        particles[i].p.position.x += diff*particles[i].speed;

                        if (particles[i].p.position.x > xlimit)
                            CreateParticle(i, lag);
                    }
                }

                this.AddToScene = function(scene)
                {
                    obj.position.z = 2;
                    scene.add(obj);
                }
            }

            function CreatePlanet()
            {
                var material = new THREE.MeshBasicMaterial({
                    map: THREE.ImageUtils.loadTexture('img/planet.png'),
                    transparent: true
                });
                var geometry = new THREE.PlaneGeometry(1, 1);
                var planet = new THREE.Mesh( geometry, material );
                planet.position.z = 1;
                planet.scale.x = planet.scale.y = 3;
                return planet;
            }

            function CreatePlanet2()
            {
                var material = new THREE.MeshBasicMaterial({
                    map: THREE.ImageUtils.loadTexture('img/planet2.png'),
                    transparent: true
                });
                var geometry = new THREE.PlaneGeometry(1, 1);
                var planet = new THREE.Mesh( geometry, material );
                planet.position.z = 0.6;
                planet.position.x = -5;
                planet.position.y = 2;
                planet.scale.x = planet.scale.y = 1;
                scene.add( planet );
            }

            function CreateStars()
            {
                var group = new THREE.Object3D;
                var material = new THREE.MeshBasicMaterial({
                    map: THREE.ImageUtils.loadTexture('img/bluestar.png'),
                    transparent: true
                });
                var sgeometry = new THREE.PlaneGeometry(1, 1);

                for(var i=0; i < 1000; ++i) {
                    if (i == 500)
                    {
                        material = new THREE.MeshLambertMaterial({
                            map: THREE.ImageUtils.loadTexture('img/whitestar.png'),
                            transparent: true
                        });
                    }

                    var celObj = new THREE.Mesh(sgeometry, material);
                    celObj.position.x = THREE.Math.randFloatSpread(20);
                    celObj.position.y = THREE.Math.randFloatSpread(10);
                    celObj.scale.x = celObj.scale.y = 0.02 + Math.random() * 0.08;
                    stars[i] = {c: celObj, s: celObj.scale.x, r: Math.random(), rs: (1.1+Math.random())};

                    group.add(celObj);
                }

                scene.add(group);
            }

            function init() {
                loader = new THREE.JSONLoader();
                scene = new THREE.Scene();

                //scene.fog = new THREE.Fog( 0xcce0ff, 500, 10000 );

                // Lights
                scene.add( new THREE.AmbientLight( 0xffffff ) );

                /*var geometry = new THREE.PlaneGeometry( 24, 24);
                var material = new THREE.MeshLambertMaterial({
                    map: THREE.ImageUtils.loadTexture('img/background.png'),
                });
                var plane = new THREE.Mesh( geometry, material );
                plane.position.z = -1;
                scene.add( plane );*/

                var planetcontainer = new THREE.Object3D;
                planetcontainer.add(CreatePlanet());
                scene.add(planetcontainer);

                planetcontainer.position.x = 4;
                planetcontainer.position.y = 0.2;

                CreatePlanet2();



                //camera = new THREE.OrthographicCamera( window.innerWidth / - 2, window.innerWidth / 2, window.innerHeight / 2, window.innerHeight / - 2, 1, 1000 );
                //scene.add( camera );
                camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 1, 100);
                camera.position.set(0, 0, 10);
                camera.lookAt(scene.position);
                scene.add(camera);

                CreateStars();

                smoke = new SmokeParticles(150);
                smoke.AddToScene(planetcontainer);

                ambientclouds = new AmbientClouds(10);
                ambientclouds.AddToScene(scene);

                movingclouds = new MovingClouds(40);
                movingclouds.AddToScene(scene);

                if (window.WebGLRenderingContext)
                    renderer = new THREE.WebGLRenderer();
                else
                    renderer = new THREE.CanvasRenderer();
                renderer.setSize( window.innerWidth, window.innerHeight );
                renderer.setClearColor(0x010010, 0);
                document.body.appendChild( renderer.domElement );
            }

            function animate() {
                var diff = Date.now() - timer;
                timer = Date.now();

                smoke.Update(diff);
                ambientclouds.Update(diff);
                movingclouds.Update(diff);


                for(var i=0; i < 1000; ++i)
                    stars[i].c.scale.x = stars[i].c.scale.y = stars[i].s + Math.sin((timer*0.002+6.28*stars[i].r)*stars[i].rs)*0.02;

                // note: three.js includes requestAnimationFrame shim
                requestAnimationFrame( animate );

                renderer.render( scene, camera );
            }

            window.addEventListener( 'resize', onWindowResize, false );

            function onWindowResize(){

                camera.aspect = window.innerWidth / window.innerHeight;
                camera.updateProjectionMatrix();

                renderer.setSize( window.innerWidth, window.innerHeight );

            }

            init();
            animate();