SolarSystem.qml Example File

  /****************************************************************************
  **
  ** Copyright (C) 2016 The Qt Company Ltd.
  ** Contact: https://www.qt.io/licensing/
  **
  ** This file is part of the Qt3D module of the Qt Toolkit.
  **
  ** $QT_BEGIN_LICENSE:BSD$
  ** Commercial License Usage
  ** Licensees holding valid commercial Qt licenses may use this file in
  ** accordance with the commercial license agreement provided with the
  ** Software or, alternatively, in accordance with the terms contained in
  ** a written agreement between you and The Qt Company. For licensing terms
  ** and conditions see https://www.qt.io/terms-conditions. For further
  ** information use the contact form at https://www.qt.io/contact-us.
  **
  ** BSD License Usage
  ** Alternatively, you may use this file under the terms of the BSD license
  ** as follows:
  **
  ** "Redistribution and use in source and binary forms, with or without
  ** modification, are permitted provided that the following conditions are
  ** met:
  **   * Redistributions of source code must retain the above copyright
  **     notice, this list of conditions and the following disclaimer.
  **   * Redistributions in binary form must reproduce the above copyright
  **     notice, this list of conditions and the following disclaimer in
  **     the documentation and/or other materials provided with the
  **     distribution.
  **   * Neither the name of The Qt Company Ltd nor the names of its
  **     contributors may be used to endorse or promote products derived
  **     from this software without specific prior written permission.
  **
  **
  ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
  **
  ** $QT_END_LICENSE$
  **
  ****************************************************************************/

  import QtQuick 2.0 as QQ2
  import Qt3D.Core 2.0
  import Qt3D.Render 2.0
  import Qt3D.Input 2.0
  import Qt3D.Logic 2.0
  import Qt3D.Extras 2.0

  import "planets.js" as Planets

  Entity {
      id: sceneRoot

      property bool ready: false

      property real cameraNear: 0
      property real xLookAtOffset: 0
      property real yLookAtOffset: 0
      property real zLookAtOffset: 0
      property real xCameraOffset: 0
      property real yCameraOffset: 0
      property real zCameraOffset: 0

      property var planetData
      property var planets: []

      property vector3d defaultUp: Qt.vector3d(0, 1, 0)
      property vector3d defaultCameraPosition: Qt.vector3d(Planets.solarDistance,
                                                           Planets.solarDistance,
                                                           Planets.solarDistance)
      property vector3d tiltAxis: Qt.vector3d(0, 0, 1)
      property vector3d rollAxis: Qt.vector3d(0, 1, 0)
      property real cameraDistance: 1
      property vector3d oldCameraPosition
      property vector3d oldFocusedPlanetPosition

      property color ambientStrengthStarfield: "#000000"
      property color ambientStrengthSun: "#ffffff"
      property color ambientStrengthClouds: "#000000"
      property color ambientStrengthRing: "#111111"
      property color ambientStrengthPlanet: "#222222"
      property real shininessSpecularMap: 50.0
      property real shininessClouds: 10.0
      property real shininessBasic: 1.0

      property real saturnRingInnerRadius
      property real saturnRingOuterRadius
      property real uranusRingInnerRadius
      property real uranusRingOuterRadius

      // Time variables
      property int year: 2000
      property int month: 1
      property int day: 1
      // Time scale formula based on http://www.stjarnhimlen.se/comp/ppcomp.html
      property real startD: 367 * year - 7 * (year + (month + 9) / 12) / 4 + 275 * month / 9 + day - 730530
      property real oldTimeD: startD
      property real currTimeD: startD
      property real deltaTimeD: 0
      property real daysPerFrame
      property real daysPerFrameScale

      property real planetScale

      property bool focusedScaling: false
      property int focusedMinimumScale: 20
      property real actualScale

      // Animate solar system with LogicComponent
      FrameAction {
          onTriggered: {
              frames++
              animate(focusedPlanet)
          }
      }

      PlanetsLight {
          id: light
          ratio: width / height
      }

      Camera {
          id: camera
          projectionType: CameraLens.PerspectiveProjection
          fieldOfView: 45
          aspectRatio: width / height
          nearPlane: 2500000.0
          farPlane: 20000000.0
          position: defaultCameraPosition
          upVector: defaultUp
          viewCenter: Qt.vector3d( xLookAtOffset, yLookAtOffset, zLookAtOffset )
      }

      FirstPersonCameraController { camera: camera }

      components: [
          PlanetFrameGraph {
              id: framegraph
              viewCamera: camera
              lightCamera: light.lightCamera
          },
          InputSettings {}
      ]

      PlanetEffect {
          id: effectD
          light: light
      }

      PlanetEffect {
          id: effectDB
          light: light
          vertexES: "qrc:/shaders/es2/planetDB.vert"
          fragmentES: "qrc:/shaders/es2/planetDB.frag"
          vertexGL: "qrc:/shaders/gl3/planetDB.vert"
          fragmentGL: "qrc:/shaders/gl3/planetDB.frag"
      }

      PlanetEffect {
          id: effectDSB
          light: light
          vertexES: "qrc:/shaders/es2/planetDB.vert"
          fragmentES: "qrc:/shaders/es2/planetDSB.frag"
          vertexGL: "qrc:/shaders/gl3/planetDB.vert"
          fragmentGL: "qrc:/shaders/gl3/planetDSB.frag"
      }

      PlanetEffect {
          id: cloudEffect
          light: light
          vertexES: "qrc:/shaders/es2/planetD.vert"
          fragmentES: "qrc:/shaders/es2/planetDS.frag"
          vertexGL: "qrc:/shaders/gl3/planetD.vert"
          fragmentGL: "qrc:/shaders/gl3/planetDS.frag"
      }

      SunEffect {
          id: sunEffect
      }

      ShadowEffect {
          id: shadowMapEffect
          shadowTexture: framegraph.shadowTexture
          light: light
      }

      QQ2.Component.onCompleted: {
          planetData = Planets.loadPlanetData()
          // Push in the correct order
          planets.push(sun)
          planets.push(mercury)
          planets.push(venus)
          planets.push(earth)
          planets.push(mars)
          planets.push(jupiter)
          planets.push(saturn)
          planets.push(uranus)
          planets.push(neptune)
          planets.push(moon)
          // TODO: Once support for creating meshes from arrays is implemented take these into use
          //saturnRing.makeRing()
          //uranusRing.makeRing()
          saturnRingOuterRadius = planetData[Planets.SATURN].radius + Planets.saturnOuterRadius
          saturnRingInnerRadius = planetData[Planets.SATURN].radius + 6.630
          uranusRingOuterRadius = planetData[Planets.URANUS].radius + Planets.uranusOuterRadius
          uranusRingInnerRadius = planetData[Planets.URANUS].radius + 2
          ready = true
          changeScale(1200)
          changeSpeed(0.2)
          setLookAtOffset(Planets.SUN)
      }

      QQ2.NumberAnimation {
          id: lookAtOffsetAnimation
          target: sceneRoot
          properties: "xLookAtOffset, yLookAtOffset, zLookAtOffset"
          to: 0
          easing.type: Easing.InOutQuint
          duration: 1250
      }

      QQ2.NumberAnimation {
          id: cameraOffsetAnimation
          target: sceneRoot
          properties: "xCameraOffset, yCameraOffset, zCameraOffset"
          to: 0
          easing.type: Easing.InOutQuint
          duration: 2500
      }

      QQ2.Behavior on cameraNear {
          QQ2.PropertyAnimation {
              easing.type: Easing.InOutQuint
              duration: 2500
          }
      }

      function changePlanetFocus(oldPlanet, focusedPlanet) {
          setOldPlanet(oldPlanet, focusedPlanet)
          setLookAtOffset(focusedPlanet)
          setCameraOffset(oldPlanet, focusedPlanet)
          lookAtOffsetAnimation.restart()
          cameraOffsetAnimation.restart()
      }

      function setOldPlanet(oldPlanet, focusedPlanet) {
          oldCameraPosition = camera.position

          var planet = 0
          if (oldPlanet !== Planets.SOLAR_SYSTEM)
              planet = oldPlanet
          oldFocusedPlanetPosition = Qt.vector3d(planets[planet].x,
                                                 planets[planet].y,
                                                 planets[planet].z)
          checkScaling(focusedPlanet)
      }

      function setScale(value, focused) {
          // Save actual scale
          if (!focused)
              actualScale = value

          // Limit minimum scaling in focus mode to avoid jitter caused by rounding errors
          if (value <= focusedMinimumScale && (focusedScaling || focused))
              planetScale = focusedMinimumScale
          else
              planetScale = actualScale
          return planetScale
      }

      function checkScaling(focusedPlanet) {
          if (focusedPlanet !== Planets.SOLAR_SYSTEM) {
              // Limit minimum scaling in focus mode to avoid jitter caused by rounding errors
              if (actualScale <= focusedMinimumScale) {
                  planetScale = focusedMinimumScale
                  changeScale(focusedMinimumScale, true)
              }
              focusedScaling = true
          } else if (focusedScaling === true) {
              // Restore normal scaling
              focusedScaling = false
              changeScale(actualScale, false)
          }
      }

      function setLookAtOffset(focusedPlanet) {
          var offset = oldFocusedPlanetPosition

          var planet = 0
          if (focusedPlanet !== Planets.SOLAR_SYSTEM)
              planet = focusedPlanet

          var focusedPlanetPosition = Qt.vector3d(planets[planet].x,
                                                  planets[planet].y,
                                                  planets[planet].z)
          offset = offset.minus(focusedPlanetPosition)

          xLookAtOffset = offset.x
          yLookAtOffset = offset.y
          zLookAtOffset = offset.z
      }

      function setCameraOffset(oldPlanet, focusedPlanet) {
          var offset = oldCameraPosition

          var planet = 0
          if (focusedPlanet !== Planets.SOLAR_SYSTEM)
              planet = focusedPlanet

          var newCameraPosition = getNewCameraPosition(focusedPlanet, Planets.getOuterRadius(planet))

          if (focusedPlanet !== Planets.SUN)
              offset = offset.minus(newCameraPosition)

          if (oldPlanet === Planets.SOLAR_SYSTEM && focusedPlanet === Planets.SUN) {
              xCameraOffset = Math.abs(offset.x)
              yCameraOffset = Math.abs(offset.y)
              zCameraOffset = Math.abs(offset.z)
          } else { // from a planet to another
              xCameraOffset = offset.x
              yCameraOffset = offset.y
              zCameraOffset = offset.z
          }
      }

      function getNewCameraPosition(focusedPlanet, radius) {
          var position
          if (focusedPlanet === Planets.SOLAR_SYSTEM) {
              position = defaultCameraPosition
              position = position.times(cameraDistance)
          } else if (focusedPlanet === Planets.SUN) {
              position = Qt.vector3d(radius * planetScale * 2,
                                     radius * planetScale * 2,
                                     radius * planetScale * 2)
              position = position.times(cameraDistance)
          } else {
              var vec1 = Qt.vector3d(planets[focusedPlanet].x,
                                     planets[focusedPlanet].y,
                                     planets[focusedPlanet].z)
              var vec2 = defaultUp
              vec1 = vec1.normalized()
              vec2 = vec2.crossProduct(vec1)
              vec2 = vec2.times(radius * planetScale * cameraDistance * 4)
              vec2 = vec2.plus(Qt.vector3d(planets[focusedPlanet].x,
                                           planets[focusedPlanet].y,
                                           planets[focusedPlanet].z))
              vec1 = Qt.vector3d(0, radius * planetScale, 0)
              vec2 = vec2.plus(vec1)
              position = vec2
          }
          return position
      }

      function advanceTime(focusedPlanet) {
          if (focusedPlanet === Planets.SOLAR_SYSTEM)
              daysPerFrame = daysPerFrameScale * 10
          else
              daysPerFrame = daysPerFrameScale * planetData[focusedPlanet].period / 100.0

          // Advance the time in days
          oldTimeD = currTimeD
          currTimeD = currTimeD + daysPerFrame
          deltaTimeD = currTimeD - oldTimeD
      }

      function positionPlanet(i) {
          var planet = planetData[i]
          var target = planets[i]

          if (i !== Planets.SUN) {
              // Calculate the planet orbital elements from the current time in days
              var N = (planet.N1 + planet.N2 * currTimeD) * Math.PI / 180
              var iPlanet = (planet.i1 + planet.i2 * currTimeD) * Math.PI / 180
              var w = (planet.w1 + planet.w2 * currTimeD) * Math.PI / 180
              var a = planet.a1 + planet.a2 * currTimeD
              var e = planet.e1 + planet.e2 * currTimeD
              var M = (planet.M1 + planet.M2 * currTimeD) * Math.PI / 180
              var E = M + e * Math.sin(M) * (1.0 + e * Math.cos(M))

              var xv = a * (Math.cos(E) - e)
              var yv = a * (Math.sqrt(1.0 - e * e) * Math.sin(E))
              var v = Math.atan2(yv, xv)

              // Calculate the distance (radius)
              var r = Math.sqrt(xv * xv + yv * yv)

              // From http://www.davidcolarusso.com/astro/
              // Modified to compensate for the right handed coordinate system of OpenGL
              var xh = r * (Math.cos(N) * Math.cos(v + w)
                            - Math.sin(N) * Math.sin(v + w) * Math.cos(iPlanet))
              var zh = -r * (Math.sin(N) * Math.cos(v + w)
                             + Math.cos(N) * Math.sin(v + w) * Math.cos(iPlanet))
              var yh = r * (Math.sin(w + v) * Math.sin(iPlanet))

              // Apply the position offset from the center of orbit to the bodies
              var centerOfOrbit = planet.centerOfOrbit
              target.x = planets[centerOfOrbit].x + xh * Planets.auScale
              target.y = planets[centerOfOrbit].y + yh * Planets.auScale
              target.z = planets[centerOfOrbit].z + zh * Planets.auScale
          }
          // Calculate the rotation (roll) of the bodies. Tilt does not change.
          target.roll += (deltaTimeD / planet.period) * 360 // In degrees
      }

      function changeScale(scale, focused) {
          if (!ready)
              return

          var scaling = setScale(scale, focused)
          sun.r = planetData[Planets.SUN].radius * scaling / 100
          mercury.r = planetData[Planets.MERCURY].radius * scaling
          venus.r = planetData[Planets.VENUS].radius * scaling
          earth.r = planetData[Planets.EARTH].radius * scaling
          earthClouds.r = planetData[Planets.EARTH].radius * scaling * 1.02
          moon.r = planetData[Planets.MOON].radius * scaling
          mars.r = planetData[Planets.MARS].radius * scaling
          jupiter.r = planetData[Planets.JUPITER].radius * scaling
          saturn.r = planetData[Planets.SATURN].radius * scaling
          saturnRing.outerRadius = saturnRingOuterRadius * scaling
          saturnRing.innerRadius = saturnRingInnerRadius * scaling
          uranus.r = planetData[Planets.URANUS].radius * scaling
          uranusRing.outerRadius = uranusRingOuterRadius * scaling
          uranusRing.innerRadius = uranusRingInnerRadius * scaling
          neptune.r = planetData[Planets.NEPTUNE].radius * scaling
      }

      function changeSpeed(speed) {
          daysPerFrameScale = speed
      }

      function changeCameraDistance(distance) {
          cameraDistance = distance
      }

      function animate(focusedPlanet) {
          if (!ready)
              return

          advanceTime(focusedPlanet)
          for (var i = 0; i <= Planets.NUM_SELECTABLE_PLANETS; i++)
              positionPlanet(i)

          updateCamera(focusedPlanet)
      }

      function updateCamera(focusedPlanet) {
          // Get the appropriate near plane position for the camera and animate it with QML animations
          var outerRadius = Planets.getOuterRadius(focusedPlanet)
          cameraNear = outerRadius
          camera.nearPlane = cameraNear
          light.near = cameraNear

          // Calculate position
          var cameraPosition = getNewCameraPosition(focusedPlanet, outerRadius)
          var cameraOffset = Qt.vector3d(xCameraOffset, yCameraOffset, zCameraOffset)
          cameraPosition = cameraPosition.plus(cameraOffset)

          // Calculate look-at point
          var lookAtPlanet = Planets.SUN
          if (focusedPlanet !== Planets.SOLAR_SYSTEM)
              lookAtPlanet = focusedPlanet
          var cameraLookAt = Qt.vector3d(planets[lookAtPlanet].x,
                                         planets[lookAtPlanet].y,
                                         planets[lookAtPlanet].z)
          var lookAtOffset = Qt.vector3d(xLookAtOffset, yLookAtOffset, zLookAtOffset)
          cameraLookAt = cameraLookAt.plus(lookAtOffset)

          // Set position and look-at
          camera.viewCenter = cameraLookAt
          camera.position = Qt.vector3d(cameraPosition.x, cameraPosition.y, cameraPosition.z)
          camera.upVector = defaultUp
      }

      //
      // STARFIELD
      //

      Entity {
          id: starfieldEntity

          Mesh {
              id: starfield
              source: "qrc:/meshes/starfield.obj"
          }

          PlanetMaterial {
              id: materialStarfield
              effect: effectD
              ambientLight: ambientStrengthStarfield
              specularColor: Qt.rgba(0.0, 0.0, 0.0, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/galaxy_starfield.jpg"
              shininess: 1000000.0
          }

          property Transform transformStarfield: Transform {
              scale: 8500000
              translation: Qt.vector3d(0, 0, 0)
          }

          components: [ starfield, materialStarfield, transformStarfield ]
      }

      //
      // SUN
      //

      Entity {
          id: sunEntity

          Planet {
              id: sun
              tilt: planetData[Planets.SUN].tilt
          }

          PlanetMaterial {
              id: materialSun
              effect: sunEffect
              ambientLight: ambientStrengthSun
              diffuseMap: "qrc:/images/solarsystemscope/sunmap.jpg"
          }

          property Transform transformSun: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(sun.x, sun.y, sun.z))
                  m.rotate(sun.tilt, tiltAxis)
                  m.rotate(sun.roll, rollAxis)
                  m.scale(sun.r)
                  return m
              }
          }

          components: [ sun, materialSun, transformSun ]
      }

      //
      // PLANETS
      //

      // MERCURY

      Entity {
          id: mercuryEntity

          Planet {
              id: mercury
              tilt: planetData[Planets.MERCURY].tilt
          }

          PlanetMaterial {
              id: materialMercury
              effect: effectDB
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/mercurymap.jpg"
              normalMap: "qrc:/images/solarsystemscope/mercurynormal.jpg"
              shininess: shininessSpecularMap
          }

          property Transform transformMercury: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(mercury.x, mercury.y, mercury.z))
                  m.rotate(mercury.tilt, tiltAxis)
                  m.rotate(mercury.roll, rollAxis)
                  m.scale(mercury.r)
                  return m
              }
          }

          components: [ mercury, materialMercury, transformMercury ]
      }

      // VENUS

      Entity {
          id: venusEntity

          Planet {
              id: venus
              tilt: planetData[Planets.VENUS].tilt
          }

          PlanetMaterial {
              id: materialVenus
              effect: effectDB
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/venusmap.jpg"
              normalMap: "qrc:/images/solarsystemscope/venusnormal.jpg"
              shininess: shininessSpecularMap
          }

          property Transform transformVenus: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(venus.x, venus.y, venus.z))
                  m.rotate(venus.tilt, tiltAxis)
                  m.rotate(venus.roll, rollAxis)
                  m.scale(venus.r)
                  return m
              }
          }

          components: [ venus, materialVenus, transformVenus ]
      }

      // EARTH

      Entity {
          id: earthEntity

          Planet {
              id: earth
              tilt: planetData[Planets.EARTH].tilt
          }

          PlanetMaterial {
              id: materialEarth
              effect: effectDSB
              ambientLight: ambientStrengthPlanet
              diffuseMap: "qrc:/images/solarsystemscope/earthmap2k.jpg"
              specularMap: "qrc:/images/solarsystemscope/earthspec2k.jpg"
              normalMap: "qrc:/images/solarsystemscope/earthnormal2k.jpg"
              shininess: shininessSpecularMap
          }

          property Transform transformEarth: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(earth.x, earth.y, earth.z))
                  m.rotate(earth.tilt, tiltAxis)
                  m.rotate(earth.roll, rollAxis)
                  m.scale(earth.r)
                  return m
              }
          }

          components: [ earth, materialEarth, transformEarth ]
      }

      // EARTH CLOUDS

      Entity {
          id: earthCloudsEntity

          Planet {
              id: earthClouds
              tilt: planetData[Planets.EARTH].tilt
          }

          PlanetMaterial {
              id: materialEarthClouds
              effect: cloudEffect
              ambientLight: ambientStrengthClouds
              diffuseMap: "qrc:/images/solarsystemscope/earthcloudmapcolortrans.png"
              specularMap: "qrc:/images/solarsystemscope/earthcloudmapspec.jpg"
              shininess: shininessClouds
              opacity: 0.2
          }

          property Transform transformEarthClouds: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(earth.x, earth.y, earth.z))
                  m.rotate(earth.tilt, tiltAxis)
                  m.rotate(earth.roll / 1.2, rollAxis)
                  m.scale(earthClouds.r)
                  return m
              }
          }

          components: [ earthClouds, materialEarthClouds, transformEarthClouds ]
      }

      // MOON

      Entity {
          id: moonEntity

          Planet {
              id: moon
              tilt: planetData[Planets.MOON].tilt
          }

          PlanetMaterial {
              id: materialMoon
              effect: effectDB
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/moonmap2k.jpg"
              normalMap: "qrc:/images/solarsystemscope/moonnormal2k.jpg"
              shininess: shininessSpecularMap
          }

          property Transform transformMoon: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(moon.x, moon.y, moon.z))
                  m.rotate(moon.tilt, tiltAxis)
                  m.rotate(moon.roll, rollAxis)
                  m.scale(moon.r)
                  return m
              }
          }

          components: [ moon, materialMoon, transformMoon ]
      }

      // MARS

      Entity {
          id: marsEntity

          Planet {
              id: mars
              tilt: planetData[Planets.MARS].tilt
          }

          PlanetMaterial {
              id: materialMars
              effect: effectDB
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/marsmap2k.jpg"
              normalMap: "qrc:/images/solarsystemscope/marsnormal2k.jpg"
              shininess: shininessSpecularMap
          }

          property Transform transformMars: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(mars.x, mars.y, mars.z))
                  m.rotate(mars.tilt, tiltAxis)
                  m.rotate(mars.roll, rollAxis)
                  m.scale(mars.r)
                  return m
              }
          }

          components: [ mars, materialMars, transformMars ]
      }

      // JUPITER

      Entity {
          id: jupiterEntity

          Planet {
              id: jupiter
              tilt: planetData[Planets.JUPITER].tilt
          }

          PlanetMaterial {
              id: materialJupiter
              effect: effectD
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/jupitermap.jpg"
              shininess: shininessBasic
          }

          property Transform transformJupiter: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(jupiter.x, jupiter.y, jupiter.z))
                  m.rotate(jupiter.tilt, tiltAxis)
                  m.rotate(jupiter.roll, rollAxis)
                  m.scale(jupiter.r)
                  return m
              }
          }

          components: [ jupiter, materialJupiter, transformJupiter ]
      }

      // SATURN

      Entity {
          id: saturnEntity

          Planet {
              id: saturn
              tilt: planetData[Planets.SATURN].tilt
          }

          PlanetMaterial {
              id: materialSaturn
              effect: shadowMapEffect
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/saturnmap.jpg"
              shininess: shininessBasic
          }

          property Transform transformSaturn: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(saturn.x, saturn.y, saturn.z))
                  m.rotate(saturn.tilt, tiltAxis)
                  m.rotate(saturn.roll, rollAxis)
                  m.scale(saturn.r)
                  return m
              }
          }

          components: [ saturn, materialSaturn, transformSaturn ]
      }

      // SATURN RING

      Entity {
          id: saturnRingEntity

          Ring {
              id: saturnRing
              innerRadius: saturnRingInnerRadius
              outerRadius: saturnRingOuterRadius
          }

          PlanetMaterial {
              id: materialSaturnRing
              effect: shadowMapEffect
              ambientLight: ambientStrengthRing
              specularColor: Qt.rgba(0.01, 0.01, 0.01, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/saturnringcolortrans.png"
              shininess: shininessBasic
              opacity: 0.4
          }

          property Transform transformSaturnRing: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(saturn.x, saturn.y, saturn.z))
                  m.rotate(saturn.tilt, tiltAxis)
                  m.rotate(saturn.roll / 10, rollAxis)
                  m.scale((saturnRing.innerRadius + saturnRing.outerRadius) / 1.75)
                  return m
              }
          }

          components: [ saturnRing, materialSaturnRing, transformSaturnRing ]
      }

      // URANUS

      Entity {
          id: uranusEntity

          Planet {
              id: uranus
              tilt: planetData[Planets.URANUS].tilt
          }

          PlanetMaterial {
              id: materialUranus
              effect: shadowMapEffect
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/uranusmap.jpg"
              shininess: shininessBasic
          }

          property Transform transformUranus: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(uranus.x, uranus.y, uranus.z))
                  m.rotate(uranus.tilt, tiltAxis)
                  m.rotate(uranus.roll, rollAxis)
                  m.scale(uranus.r)
                  return m
              }
          }

          components: [ uranus, materialUranus, transformUranus ]
      }

      // URANUS RING

      Entity {
          id: uranusRingEntity

          Ring {
              id: uranusRing
              innerRadius: uranusRingInnerRadius
              outerRadius: uranusRingOuterRadius
          }

          PlanetMaterial {
              id: materialUranusRing
              effect: shadowMapEffect
              ambientLight: ambientStrengthRing
              specularColor: Qt.rgba(0.01, 0.01, 0.01, 1.0)
              diffuseMap: "qrc:/images/nasa/uranusringcolortrans.png"
              shininess: shininessBasic
              opacity: 0.4
          }

          property Transform transformUranusRing: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(uranus.x, uranus.y, uranus.z))
                  m.rotate(uranus.tilt, tiltAxis)
                  m.rotate(uranus.roll / 10, rollAxis)
                  m.scale((uranusRing.innerRadius + uranusRing.outerRadius) / 1.75)
                  return m
              }
          }

          components: [ uranusRing, materialUranusRing, transformUranusRing ]
      }

      // NEPTUNE

      Entity {
          id: neptuneEntity

          Planet {
              id: neptune
              tilt: planetData[Planets.NEPTUNE].tilt
          }

          PlanetMaterial {
              id: materialNeptune
              effect: effectD
              ambientLight: ambientStrengthPlanet
              specularColor: Qt.rgba(0.2, 0.2, 0.2, 1.0)
              diffuseMap: "qrc:/images/solarsystemscope/neptunemap.jpg"
              shininess: shininessBasic
          }

          property Transform transformNeptune: Transform {
              matrix: {
                  var m = Qt.matrix4x4()
                  m.translate(Qt.vector3d(neptune.x, neptune.y, neptune.z))
                  m.rotate(neptune.tilt, tiltAxis)
                  m.rotate(neptune.roll, rollAxis)
                  m.scale(neptune.r)
                  return m
              }
          }

          components: [ neptune, materialNeptune, transformNeptune ]
      }
  }