tech:tutorials []

Texture Images

Deepsky images: https://svs.gsfc.nasa.gov/4851/
Solar Textures: https://www.solarsystemscope.com/textures/

Calculating the position of an orbiting body in an orbit defined by Orbital Elements

See this page for the introduction and the detailed step-by-step calculation orbit_calculation.

There is a Python package called pyorb that can calculate Keplerian (i.e., $xyz$) from reference ($IJK$) or vice versa.

A good introduction on the whole calculation step (and the visualization of the orbital elements) is available from this YouTube video.

Check this YouTube video for Keplerian orbital elements and Euler Angles: https://www.youtube.com/watch?v=bgFaDDt0Rn4

To get orbital elements of Solar System objects, check NASA JPL Horizon.

Tutorials for Beginngers

This introduction to blender documentation prepared by Michael Cai will be useful for students new to 3D programming.

Here is the link to the shared document. And here is the link to all shared Blender files.

Use this link to convert the Google Doc tutorial shown above to a dw content. https://cgcookie.com/ offers many Blender tutorials. </panel>

Useful tips for creating objects in the Blender night sky

A preliminary version of the celestial sphere simulation by using NASA HDRI maps as the Blender World Background Texture was created and the tutorial on how to create such “Night Sky World” is shown in Simulating Celestial Sphere in Blender.

You need to download relevant NASA star maps and link them in the node editor to see the starry background.
In Blender rendering, because we are rendering only the changes of the background pixelated images (and no 3-D object), we can turn off ray tracing (Render → Light Paths → max bounce = 1) and set the cycles render's sampling to be 1 (Sampling → Render → Max Samples = 1). Then, it should take less than 10 sec per scene (~20 min rendering for 240 frame animation).

See these examples for creating a virtual, realistic, night sky in Blender:

Horizon + Mountain + Real nightsky from NASA: here (watch from 19m:10s)
Create bright Sun“ Sun
Check this GitHub page which provides “Blender-CelestialSimulator” with Python: https://github.com/Yuxiza/Blender-CelestialSimulator

https://www.youtube.com/watch?v=RY2_Lhfy53M This simulates 1000 nearby stars. However, this is a collection of 1000 objects (i.e., stars) not a real simulation of the Celestial Sphere.
There was a relevant question but answers to the question are not helpful.https://blender.stackexchange.com/questions/179119/guidance-on-creating-a-celestial-sphere
https://blenderartists.org/t/using-blender-to-make-a-real-life-celestial-globe/683089 Not the same one we are trying to build. This attempt is trying to project onto the outer surface area contrary to out case of projection to the interior surface of the Celestial sphere. Again, no helpful info in the answer.
https://blendermarket.com/products/real-world-starsky-generator This one is listed in the Blender market (for $12). This is close to what we intend to create. ⇒ Can we purchase this one and modify it to fit our need? What's the license term?

Check this 3D Star Map Add-on in Blender which uses a dataset of real nearby ~3,000 stars. This also shows how to simulate a night sky (i.e., celestial sphere). A free demo version has 299 stars without constellation markings. ⇒ This shows a good tip on how to display texts on the scene (text fixed with respect to a camera)
NASA image as the HDRI background with constellation lines: Blender-Night-Sky ⇒ This demo also provides a Blender file that shows tips on how to use dynamic camera control (i.e., dynamically changing camera position, origin [i.e., camera field-of-view], etc.)
Blender 3.? and later versions provide a Geometry Node which can be used in simulating a planet in a orbit around its central star. Check this tutorial: https://www.youtube.com/watch?v=9haf_JsqKlY. Using orbital elements from JPL (https://ssd.jpl.nasa.gov/planets/approx_pos.html), one can do a decent planetary orbit simulation.
Check this GitHub page https://github.com/markus-ebke/SolarSystemSimulator showing a Blender package for simulating Solar System from orbital elements.
- This package can simulate an orbit of a planet around a central star with all user-configurable physical parameters (mass, rotation rate, rotation axis tilt angle, orbital elements, etc.).
- This package also display animated orbital elements annotations in the 3D render.

Simulate/Visualize Orbital Motions

Solar System Simulator has a good tool to create and visualize a Keplerian orbiting system from orbital elements: https://github.com/markus-ebke/SolarSystemSimulator
https://github.com/japhir/visualise-orbitN uses the output of orbitN (A symplectic integrator for planetary systems dominated by a central mass; 2024 AJ) and visualize in Blender. Positions of planets are likely accurate.

Blender Add-ons for Space Scene

Check this YouTube video introducing 6 add-ons (https://www.youtube.com/watch?v=We6xdvd-7u8). None of these are free though.

Python in Blender

Good tutorials from YouTube on Python in Blender

Watch this first if you are new to Blender: https://www.youtube.com/watch?v=Rqhtw7dg6Wk:Blender in 20min
Watch this first if you are new to Python scripting in Blender: Getting Started with Scripting in Python
Good intro in general and how to make an addon with Python: Python Crash Course for Blender
Cool animation, collections, and context: Animation with Python in Blender

2024/04/20 13:31 · song

Share project with others

For you:
- Right-click your project folder in Project view > Export package > Export (make sure everything is selected) > Choose a place > Send him the package
Someone:
- Create new project > File > Open Scene > Double clicks it

Unity object, asset, prefab, and package

component: fundamental ingredients such as button, text, image, audio, etc.
game object: a basic container of components
asset: a file representing any item that can be used in the project
prefab: a saved, fully configured GameObject that can be used in other scenes or projects
package: a collection of files and data for a Unity project stored in a single file

Orbiting/Rotating Earth on a tilted axis

https://www.youtube.com/watch?v=oW9gzkR1yuw

Physically Based Sky Virtual Sky

This page describes how to create a Unity HDRP virtual sky model with the Physically Based Sky from the scratch. I used the hints from https://www.youtube.com/watch?v=tpTzwyiGByE in using the PBS.

It is assumed that there is a separate folder, named “PBR_Tutorial”, in the Project section (under Assets) where the sample scene is to be created and stored. If the folder does not exist, you can create one (or store subsequent items in your folder).

Steps

Make sure that you are using the HDRP rendering pipeline

Download or locate the deepsky images from NASA (https://svs.gsfc.nasa.gov/4851/). Download 16K or 4K.
1. download the star map, coordinate grid map, constellation boundary, and constellation shape.
2. store them in “Textures” folder so that other projects can use them as well.
3. convert the image to the Cube Shape (click the image –> Texture Shape in the Inspector –> select “Cube”. Set the right “Max Size” under “Default”
Delete everything in the current hierarchy.
Create a new scene: Right-click on the Assests folder –> Create –> Scene
Create a Global Volume: Right-click on the hierarchy –> Volume –> Global Volume
1. Click “New” in the Inspector panel.
2. Click “Add Override” –> Sky –> Physically Based Sky
  1. Select Model–>Type = Earth (Advanced)
  2. Click Space –> Space Emission Texture and set it to the downloaded deepsky image.
3. Click “Add Override” –> Visual Environment
  1. Set Sky Type to “Physically Based Sky”

Diurnal rotation of the sky can be simulated by “Gloval Volume” –> “Space” –> “Space Rotation”

Changing the angle of the directional light can simulate the movement of the Sun in the sky. Also, the diurnal rotation can be controlled as shown in the below image.

Improvements to be added

Check if multiple textures can be blended (i.e., displaying deep sky map with alpha-channel coordinate grid) =⇒ we may have to use the Shader Graph to blend textures.
Script controlling of the Sun and sky rotation
Overlay toggleable coordinate grid, constellation maps. How? Is it possible?
Add horizon etc.

— Inseok Song 2024/11/18 18:38

2024/11/18 18:01 · song

Check SimpleKeplerOrbits

There is a free asset called, SimplerKeplerOrbits, in the Unity asset store. It has three sample scenes and we can use this package as the starting point to create our desired Solar System simulation. Especially, check Example 3 in the included scenes which allows users' tilting and zooming actions in the rendered window (i.e. in the GamePlay mode), and it also allows to set the observing date (set to “now” automatically). There is a UI slider that can speed up and go backward in time as well. Nice! We can recycle most of these in our 3-D model.

We can create a realistic Solar System model with three free Unity assets (Simple Kepler Orbits, Planets of the Solar System, and MilkyWay).

For example, we can create a simple model by following the sequence of operations below.

Start a new 3D Unity project
Set project setting (Edit → Project Settings; pay attention to Graphics [Rendering], Quality etc.)
Import necessary assets (Package Manager: Install assets from My Assets)
In the main camera setting, choose the right Renderer and select “Post Processing”. Choose the MilkyWay skybox (drag one onto the main camera).
Create three objects (two spheres and one object). You can drag and drop Sun and Earth from “Planets of the Solar System”. One sphere is an attractor (i.e., the central star), the other sphere is an orbiting object (e.g., Earth), and the 3rd object is a velocity indicator. This is an easy approach, but in our desired model, we want to calculate orbital motion by solving Kepler equation in conjunction with six orbital elements.
1. Drag and drop “KeplerOrbitMover” script on the orbiting object. Drop “KeplerOrbitLineDisplay” on the orbiting object as well if orbits need to be displayed with curves.
2. Then, select the central object as the attractor and set the right mass value.
3. Set velocity handle, length scale, and time scale.
Render and you can see an animation.

Check “Fast Script Reload” asset which may decrease the loading time of the script.

Procedural (Script-based) Sun-Earth-Moon Model Creation

Click here to see detailed step-by-step procedure to create a Sun-Earth-Moon model

Remember that in Unity, the Y-axis is chosen to be the vertical axis unlike the astronomical convention, Blender, and even Unreal Engine.

The following C# code is to implement a rotation of a GameObject (e.g., planet). Just attach this script to an object and set two parameters (rotation w.r.t and speed).

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Rotate : MonoBehaviour
{
    public Transform target;
    public int speed;
 
    // Update is called once per frame
    void Update()
    {
        transform.RotateAround(target.transform.position, target.transform.up, speed * Time.deltaTime);
    }
}

This example creates a model of Sun-Earth-Moon with realistic surface textures and rotational/orbital motions.

Create a new project from Unity Hub (Choose the Universal 3D Core [Not the one with Build-in Render Pipeline])
In the Unity Editor
Configure Build parameters: File → Build Settings: Check if the platform is correct.
Configure Project settings: Edit → Project Settings;
- import 'TextMesh Pro' if you plan to use texts
- import 'XR Plugin' if you are building a VR model
Import relevant assets: Window → Package Manager, select 'My Assests' and import the following assets (these assets can be purchased for free in Unity Asset Store)
- Milky Way Skybox
- Planets of the Solar System 3D
- Simpler Kepler Orbits
Create a folder to store C# scripts: In the Project > Assests, right-click on the background and create a folder named “Scripts”.
Simulation background setting: Click the “main camera”, then Component > Rendering > Skybox. Then choose the Milky Way skybox in the “Custrom Skybox” panel.
Make the Sun (and set its rotate it)
Prpare for the Solar System Container: Since objects in this example are automatically created through the script “JPLOrbitLoader.cs”, we need to prepare a container and attach this script to the container.
1. Create an empty, “SEM Container” and make it inactive (click the check mark off from the inspector panel).
2. Create an empty under SEM_Container, “BodyTemplate”, with two child objects: “Velocity” empty and “View” sphere mesh.
3. Create an empty under SEM_Container, “ScreenSpaceOrbitLineTemplate”.
  1. Attach “JPLOrbitLoader.cs” to SEM_Container and set the followings:
    1. set G-constant (6.67E-11)
    2. Scale_per_diameter (0.1)
    3. Body Template = 'BodyTemplate'
    4. Jason Data = <yourinput.json>
  2. Attch “TimeController.cs” and set default date/time
  3. Attach “ScreenSpaceOrbitsDisplay” and set
    1. Target Camera → Main Camera
    2. Line Template → “ScreenSpaceOrbitLineTemplate”
    3. Cam Distance = 0.7
4. Attach “KeplerOrbitMover.cs” to “BodyTemplate” and set
  1. Velocity Handle = “Velocity” ←- the empty under BodyTemplate
  2. Time Scale = 1
  3. Lock Orbit Editing = True
5. Attach “KeplerOrbitLineDisplay” to “BodyTemplate” and set
  1. Line Renderer Reference = “ScreenSpaceOrbitLineTemplate”
  2. Select desired Gizmo options
6. Create UI canvas and panel with Input fields for YYYY/MM/DD HH:MM:SS, buttons (reset and set_time_now), and timescale input field and slider.
  1. Attach “TimeControlPanel.cs” to panel and set corresponding items to the UI objects.
  2. Check the Canvas Scaler setting: Resolution = 1280×1024
Click “Play” and you will see an animated Solar System objects showing orbital motions.
1. Drag and drop 'Rotate.cs' on Sun Empty: set target (Sun Empty) and speed.

Future Improvements:

Add “Rotate.cs” to a certain script so that we can set the rotation of each object (with correct tilt of the rotation axis)
Add realistic texture material for each object.
Add additional camera views
1. top-view camera
2. Earth-following camera (same orbital speed but slightly displace from the Earth so that one can see the shadowing of the Earth or Moon (i.e., eclipses)).
3. Add shadow cones to see the relationship among Sun, Earth, and Moon's position and shadows
4. Mars-tracking camera (to demonstrate the retrograde motion of Mars)
5. Moon-tracking camera (to see the phase change and libration)

This is a screen recording of the rendered model from the above procedure.

And this is the link to [[the Unity package file for this model.

2024/04/25 14:16 · song

Sample WebGL model of the Sun-Earth-Moon System

This embedded WebGL rendering of the Sun-Earth-Moon system created with Unity can be played in any modern web browser. The right mouse button can tilt/rotate the scene, the middle mouse button scroll adjusts a zoom level. Click the image below to access the model.

.

Setup VR with a Quest Headset

Detailed step-by-step tutorial (created by Ricky Correia):unity_to_vr.docx

General Steps:

Create a Meta account
Enable Developer mode
Enable Quest Link
Meta Quest Developer Hub (MQDH)

MicroSoft also has this tutorial: MS + Quest

Creating AR

This video describes the steps to create an AR video using Unity. Blender files can be imported to Unity.

This video demonstrates an example AR model.

Render 2+ camera views

Create cameras as you need. Then, change the “Viewport Rect” (Width and Height and X & Y) to set the desired location and size you need. In the render view then, you will have more than one camera views.

Display UI info and tools

You can add many UI components in three different ways in Unity by changing the “Render Mode”: (1) screen overlay (always displayed on screen), (2) camera space (displayed over camera view), and (3) world space (as if they are regular objects).