Features

Feature folders contain mostly code and example scenes for a specific SGT feature. For example, the Atmosphere folder contains components and shaders allowing you to add an atmosphere to your planets.

Packs

Pack folders contain mostly media and example scenes that combine multiple SGT features into one scene. For example, the Alien Worlds Pack contains a selection of alien planet textures, materials, and demo scenes.

[FREE] Alien Worlds Pack

This pack contains a selection of realistic looking planets with an alien theme.

You can download it from HERE.

[FREE] Galaxy Pack

This pack contains a variety of galaxies.

You can download it from HERE.

[FREE] Nebula Pack

This pack contains a variety of nebulae.

You can download it from HERE.

[FREE] Solar System Pack

This pack contains all major solar system bodies, including the Moon and multiple versions of The Sun.

You can download it from HERE.

[PAID] Space Graphics Planets

This pack contains 25 high resolution planets across a wide range of planet types. The main SGT asset only contains 2, so this pack is great if you want lots more planets.

You can find more information about it from HERE.

Better Shaders

This compatibility was made possible using the Better Shaders system (not required).

The Better Shaders asset generates multiple variants of each shader ahead of time, so even if you don't have this asset you will still be able to have full render pipeline compatibility with SGT.

BetterShaders (and therefore this asset) currently supports:

Standard - All versions supported by SGT.

URP7.x in Unity 2019.3LTS

URP10.x in Unity 2020.3LTS

URP12.x in Unity 2021.2

URP14.x in Unity 2022.2->2022.3LTS

HDRP7.x in Unity 2019.3LTS

HDRP10.x in Unity 2020.3LTS

HDRP12.x in Unity 2021.3LTS

HDRP14.x in Unity 2022.2->2022.3LTS

Support for newer versions will appear when it does in this asset.

Lights

Many SGT components (e.g. atmosphere) implement their own custom lighting. To make a normal Unity light compatible with them you must add the SgtLight component to it. This will automatically read the Unity light's color, intensity, position, etc.

Lights behave differently in each rendering pipeline, so the CwLightIntensity component has been added to all the demo scene lights. This component has the ability to override the light intensity for each pipeline. For example, if the IntensityInURP setting is set to 100, then when your project uses URP, the light's intensity will automatically be changed to 100.

Depth Mode (Standard)

Some feature of SGT (e.g. Terrain Ocean and Softness) require scene depth information to render properly. By default, cameras does not generate this, so you must manually add the CwDepthTextureMode component to your camera, and set the DepthMode setting to Depth or DepthNormals.

Depth Texture & Opaque Texture (URP)

Some features of SGT like SgtBlackHole and the Terrain Ocean shader require scene depth and scene color information. By default, these are not generated in URP, you must enable the Depth Texture and/or Opaque Texture setting in your pipeline settings asset.

Volume (HDRP)

To make HDRP compatibility seamless, each demo scene contains the Demo GameObject, which has the SgtDemo component. This component adds the Volume component in HDRP.

This volume will adjust the scene exposure, disable the visual environment, and disable fog. These are all done to make the scenes look consistent with the other rendering pipelines. If you want to adjust these settings yourself then you can delete this component and adjust the volume settings yourself, or delete this GameObject and create your own volume.

Atmosphere Scattering HDR (Standard (HDR) + URP (HDR))

If your camera uses HDR rendering and your scene uses atmospheric scattering, you should enable the atmosphere material's LIGHTING SCATTERING HDR setting. This will modify the atmospheric scattering shader to perform calculations that can exceed the standard 0..1 (0..255) color range, making it suitable for HDR rendering.

Atmosphere Brightness (HDRP)

All SGT demo scenes were designed to look best in the standard and URP rendering pipelines. In HDRP, the atmosphere rendering can appear brighter than expected. To fix this, you may want to reduce the SgtAtmosphere component's Brightness settings. A setting of 0.6 makes it look similar to other pipelines.

If your atmosphere uses scattering, then you may also want to update the atmosphere material's ScatteringStrengths settings. For example, you could multiply them by 0.5.

Black Holes (URP)

In URP, the SgtBlackHole component works by distorting the OpaqueTexture of the scene around the black hole. As the name suggests, this means the distortion doesn't show any transparent objects. In most of the example scenes the background starfield is transparent, so it will not appear. To make them appear and still keep them transparent, you can find the backdrop/starfield material used to render the background, and change its RenderQueue setting to be 2001 (Geometry + 1). You can do the same thing for other transparent effects you want to appear in the black hole distortion, like the spacetime effect in the Gravitational Waves demo scene.

Shader Warnings

When you first import this asset you may see some shader warnings in the console. These are harmless and you can clear/ignore them, and they won't appear any more.

If however you see errors coming from SGT shaders then let me know!

Depth Buffer Precision (OpenGL + OpenGL ES)

Some scenes in SGT require very large view distances, which is achieved by increasing the camera's Clipping Planes / Far to a suitable value. This works well on consoles, Direct3D, Vulkan, and Metal due to using a reversed z buffer, but notably OpenGL and OpenGL ES don't support this (at least in Unity). This means rendering of the scenes with with this extreme view distance will break down and suffer from z fighting and other related issues beyond about 100,000 units distance.

If you must support OpenGL and OpenGL ES with high view distance scenes where this might be an issue, then you can mitigate some of these issues by increasing the Camera Offset setting available in most components of SGT. You can also increase the camera's Clipping Planes / Near setting to reduce issues, where the highest possible value for your current scene setup should be used.

Planet Motion Blur (HDRP)

The SgtPlanet and SgtTerrain components are rendered using the Graphics.DrawMesh API, which currently doesn't have any parameter to specify its motion vectors. This means the planet surface itself will not have any motion blur, or if it does, it will not behave correctly when snapping with the Universe feature.

Massive Planet + Atmosphere + Ocean Edge Artefacts (HDRP)

If you have a massive terrain planet with a terrain ocean and atmosphere, the edge of the planet when viewed from space can appear to have some sort of pixel artefacts around the edges. This issue appears to come from motion blur, but it's unclear what causes it.

The effect of this issue can be hidden by increasing the planet's atmosphere height, or by disabling motion blur in the scene volume overrides.

Corona

This shows you how to make a basic star with a volumetric corona. This is done by adding the SgtAtmosphere component to your star, and setting the SourceMaterial setting to a material using the Space Graphics Toolkit/Atmosphere shader. You can then add the SgtAtmosphereDepthTex component, which allows you to color the corona as you desire.

Atmosphere

This shows you how the atmosphere material''s Lighting setting can be enabled, adding lighting to your atmosphere. You can then add the SgtAtmosphereLightingTex component to control the colors as you like. Keep in mind you must add the SgtLight component to your main scene light.

Sunset

This shows you how the SgtAtmosphereLightingTex component''s SunsetSharpnessR/G/B settings can be used to control the color of your planet''s sunset & sunrise.

Scattering

This shows you how the Atmosphere material''s Scattering setting can be enabled, adding light scattering to your atmosphere. You can then add the SgtAtmosphereScatteringTex component to control the colors as you like.

Customize

This shows you how to connect UI elements to atmosphere settings, allowing you to more easily see what settings change what visuals.

Aurora

This shows you how to render animated aurora around the poles of a planet. This is done by adding the SgtAurora component to your planet, and setting the SourceMaterial setting to a material using the Space Graphics Toolkit/Aurora shader. You can then add the SgtAuroraMainTex component, which allows you to color the aurora as you desire.

Backdrop

This shows you how to render clouds in the background of your scene. This is done using the SgtBackdrop component with a material using the Space Graphics Toolkit / Backdrop shader. These clouds maintain their size and rotation no matter where you look, so they look great in VR.

PowerRGB

This shows you how the Backdrop shader''s Power RGB setting can be enabled, which makes it suitable for rendering stars by only changing the color of the outside of the star texture.

ClampSizeMin

This shows you how the SgtBackdrop component''s ClampSizeMin setting can be increased, which prevents the stars from getting too small. If a star gets too small, it begins to flicker as the camera rotates.

Customize

This shows you how to control the star settings from UI sliders.

Pulse

This shows you how the backdrop material''s PULSE setting can be enabled, which causes the size of each star to pulse over time. You can control the pulse speed using the SgtBackdrop component''s StarPulseSpeedMin/Max settings.

Belt

This shows you how to render thousands of billboard asteroids that orbit with great performance. This is done using the SgtBeltSimple component with a material using the Space Graphics Toolkit / Belt_Opaque shader.

Lighting

This shows you how the belt material''s Lighting setting can be enabled, adding lighting to your asteroids. You can then add the SgtBeltLightingTex component to control the lighting gradient as you like. Keep in mind you must add the SgtLight component to your main scene light.

Colors

This shows you how the SgtBeltSimple component''s AsteroidColors setting can be used to create a color gradient of different possible asteroid colors.

Additive

This shows you how the belt material can be changed to the Space Graphics Toolkit / Belt_Additive shader, which allows you to render transparent stars.

PowerRGB

This shows you how the belt material''s POWER RGB setting can be enabled, making it more suitable for colored stars.

Custom

This shows you how the asteroid data of a belt can be manually modified. This is done by finding the SgtBelt___ component, opening its context menu (the ⋮ button), and selecting the Make Editable Copy option. This will create a new GameObject with the SgtBeltCustom component, and copy all procedural asteroid data into the Asteroids list, allowing you to manually modify them. Keep in mind if you modify this list from code, then you must manually call the DirtyMesh() method after.

Sprite Billboard Flare

This shows you how the SgtBillboard component can be added alongside the SpriteRenderer component. This turns the sprite into a billboard that always points toward the camera. The SpriteRenderer.Material can then be set to the "Billboard" material, which makes it glow.

Overlay

This shows you how to make a more impressive billboard flare using a second layer.

Depth

This shows you how to shrink the overlaid billboard when an object goes between the camera and the light. This is done by adding the SgtOcclusionScaler component to it. Keep in mind solid objects in your scene require colliders for this to work.

Pointer

This shows you how Directional lights can be used. This is done using the SgtLight.TreatAsPoint setting, and the SgtLightPointer component. Directional lights have the benefit of allowing shadows to appear on your objects, even at great distances. These SGT components then rotate the directional light toward the camera, making it act like a point light.

Debris Spawner

This shows you how the SgtDebrisSpawner component can spawn asteroid prefabs around the camera. These asteroids are randomly spawned over time, so performance should be consistent, and you can interact with them as you like. Keep in mind the asteroid positions do not persist, if you fly back they will be in new random positions.

Shape

This shows you how the SgtShapeSphere and SgtShapeGroup components are combined to make a sphere shape around the star. This shape group is then set in the SgtDebrisSpawner.SpawnInside setting, making it so asteroids will spawn more frequently near the star. Keep in mind the spawn probability is based on the SgtDebrisSpawner.Target position relative to the shape group. This means debris can spawn outside of shapes if they are small enough, and your camera is inside them.

Debris Grid

This shows you how the SgtDebrisDebris component can be used to procedurally spawn asteroids around the camera. Unlike the SgtDebrisSpawner component, these asteroids will have persistent positions. Keep in mind if you move the asteroids after they spawn then their updated position will NOT be saved.

Shape

This shows you how the SgtDebrisDebris component''s Spawn Inside setting can be used, forcing debris to only spawn near the star, or any other shapes you define in the shape group.

Flares

This shows you how the SgtFlare component can be used to generate star billboards. Normal star billboards use large sprite textures which use a lot of GPU memory, but these use very little, because the billboard shape is stored in the mesh. This component also gives you full control over the visual result, allowing you to tweak it at runtime.

Jovian

This shows you how to render a volumetric gas giant. This is done using the SgtJovian component with a material using the Space Graphics Toolkit / Jovian shader. You can then add the SgtJovianDepthTex component to control the edge gradient as you like.

Rim

This shows you how the SgtJovian.Rim__ settings can be used to control the outer edge color of the gas giant.

Lighting

This shows you how the jovian material''s Lighting setting can be enabled, adding lighting to your gas giant. You can then add the SgtJovianLightingTex component to control the lighting gradient as you like. Keep in mind you must add the SgtLight component to your main scene light.

Sunset

This shows you how the SgtJovianLightingTex.SunsetSharpnessR/G/B settings can be used to control the sunset colors.

Scattering

This shows you how the jovian material''s Scattering setting can be enabled, adding atmospheric scattering to your gas giant. You can then add the SgtJovianScatteringTex component to control the lighting gradient as you like. Keep in mind you must add the SgtLight component to your main scene light.

Flow

This shows you how the jovian material''s FLOW setting can be enabled, adding animated movement to your gas giant surface. The pixels in this texture define which direction the albedo will flow, where a color of RGB 128,128,0 = no movement, 255,128,0 = flow right, 0,128,0 = flow left, etc.

Lightning Spawner

This shows you how the SgtLightningSpawner component can procedurally spawn animated lightning around a sphere. The lightning animation is controlled by the lightning sprite(s) you specify, where the red channel defines the shape of the lightning, the green channel defines when each pixel should appear, and the blue channel defines when each pixel should disappear. For a basic setup the green channel can have values of 0, and the blue channel can have values of 255. This will make the lightning shape (red channel) appear gradually over the lifetime of the animation.

Order

This shows you how the green channel of the lightning texture can be modified to change when each pixel in the lightning texture appears. The green channel values are increased for each number in the texture to make them appear later in the animation.

Sequence

This shows you how the blue channel of the lightning texture can be used to change when each pixel disappears, allowing you to create an animation sequence. Keep in mind the blue channel should always have a higher value (brighter) than the green channel for any given pixel.

Lightning

This shows you how the animated lightning can look with a properly designed texture.

Planet

This shows you how the SgtPlanet component can be used with the SGT / Planet shader to render a basic planet. You can adjust the basic look of the planet by adjusting the material settings like the Albedo (RGB) Smoothness (A) texture, Normal texture, etc.

Displace

This shows you how the planet component's Displace setting can enabled to change the planet heights based on the heightmap set in the planet material.

Detail

This shows you how to add seamless detail textures to your planet. This is done by enabling the planet shader's SHARED / Detail R and SHARED / Normal Enabled settings. You can then set the SHARED / Normal R texture, which is a seamless normal texture that will be used by all detail levels. You can then enable the DETAIL / Enabled setting, which will apply one level of detail to your planet. If you want the detail to appear in specific areas only, then you can set the SHARED / Detail Mask (RGBA) texture. You can also enable Detail R/G/B to add even more types of detail to your planets.

Secondary

This shows you how the planet shader's second DETAIL / Enable and associated settings can be used to enhance the detail of the planet even more. This is useful if you need to zoom or fly even closer to the planet.

Water

This shows you how the planet shader's Water setting can be enabled. Then then allows you to adjust the planet component's Water Level setting.

Clamp

This shows you how the planet component's Clamp Water setting can be enabled. This forces the water to stay at the Radius value, and the max height to be at the Displacement value, making it easier to set up your scene.

Gradient

This shows you how the P3dPlanetWaterGradient component can be added alongside the planet component. This allows you to change the color of the water based on its depth.

Texture

This shows you how the P3dPlanetWaterTexture component can be added alongside the planet component. This allows you to pick a normal map for the water, and this will be applied to the planet water animated.

Coast

This shows you how the planet shader's Coast Sharpness setting can be used to adjust the transition between land and sea.

Emission

This shows you how the planet shader's Emission setting can be used to make the water glow, making it look like lava.

Atmosphere

This shows you how the planet component's Shared Material setting can be set to an atmosphere added to the planet GameObject. Keep in mind the atmosphere's Inner Mesh Radius setting should match the planet's Radius setting.

Collider

This shows you how the planet component's Mesh Collider setting can be used to generate a collider that matches the visual mesh. Keep in mind this can be slow if your mesh is high resolution. You can make a lower resolution 'invisible' planet with a collider to work around this.

Prominence

This shows you how to render solar prominences around a star. This is done using the SgtProminence component with a material using the Space Graphics Toolkit / Prominence shader.

Fade Edge

This shows you how the prominence material''s FADE EDGE setting can be enabled, causing prominence planes viewed edge-on to fade out and give a better look.

Clip Near

This shows you how the prominence material''s CLIP NEAR setting can be enabled, causing prominence planes in front of the star to fade out and give a better look.

Distortion

This shows you how the prominence material''s DISTORT setting can be enabled, causing prominence texture to change over time and ripple like a flame.

Detail

This shows you how the prominence material''s DETAIL setting can be enabled, enhancing the prominence base texture''s detail.

Accretion Disk

This shows you how to render an accretion disk. This is done using the SgtRing component with a material using the Space Graphics Toolkit / Ring shader.

Animated Noise

This shows you how the ring material''s Detail setting can be set toColor, allowing you layer in a detail texture to enhance the base accretion disk texture.

Planetary Ring

This shows you how a different ring texture can be used, making it suitable as a planetary ring.

Lighting

This shows you how the ring material''s LIGHTING setting can be enabled, adding lighting and shadows to the ring. You can then add the SgtRingLightingTex component to control the lighting gradient as you like. Keep in mind you must add the SgtLight component to your main scene light.

Scattering

This shows you how the ring material''s LIGHTING SCATTERING setting can be enabled, adding light scattering through the ring.

Planet Shadow

This shows you how the SgtShadowSphere component can be added to your planet, causing it to automatically cast shadows on rings.

Ring Shadow

This shows you how the SgtShadowRing component can be added to your ring GameObject, which causes the ring to cast shadows in your scene using the SGT shadow system. Keep in mind this requires the SgtShadowLayer component to be added to your planet to make it compatible with the SGT shadow system.

Detail

This shows you how the ring material''s DETAIL setting can be set to Alpha, allowing you to add a detail texture that makes the ring more interesting up close.

Near Fade

This shows you how the ring material''s NEAR FADE setting can be enabled, which causes the ring to fade out as the camera approaches. You can add the SgtRingNearTex component to control the fade out transition.

Customize

This shows you how to control the SgtRing.RadiusInner + RadiusOuter settings, allowing you to control the ring size at runtime.

Stars

This shows you how to render basic background stars. This is done using the SgtBackgroundMesh component, which generates a sphere of billboard quads you can texture with an additive shader. The CwFollow component can then be used to glue them to the camera, so they always appear in the background.

Clouds

This shows you how the SgtBackgroundMesh component can have larger quads and different material with a cloud texture to make a background of clouds.

Camera Controls

This shows you how the SgtCameraMove and SgtCameraLook components can be added to your camera. This allows you to move and rotate the camera in a typical freeflight camera style.

Rigidbody Controls

This shows you how the SgtCameraMove component''s Target setting can be used to control the asteroid Rigidbody instead of the camera. The TargetRotation setting can then be used to rotate it based on the control inputs.

Procedural Spin + Scale

This shows you how you can add a number of asteroids, and add variety to them with the SgtProceduralSpin and SgtProceduralScale components. Keep in mind if you''re using Rigidbodies, you should use the SgtProceduralTorque component instead.

Newtonian Gravity

This shows you how the SgtGravitySource and SgtGravityReceiver components can be combined to add newtonian gravity to your scene. The SgtProceduralForce component is also used to give initial velocity of the asteroids so they can orbit.

Planet Gravity

This shows you how to combine the Procedural Spin + Scale and Newtonian Gravity demo scenes.

Simple Orbit

This shows you how the SgtSimpleOrbit component can be used to make GameObjects orbit each other.

Shadow Layer

This shows you how SGT shadows can be applied to normal opaque objects in your scene. This is done by adding the SgtShadowLayer component to them.

Lens

This shows you how the SgtLens component can be used to render a gravitational lensing effect. This can simulate subtle lensing effects, all the way to black holes that bend light back to you. Keep in mind the lens GameObject should be on its own layer, and the lens Camera component''s CullingMask should exclude this layer.

Warp Outer

This shows you how the SgtLens component''s WarpOuter setting can adjust the voerall size of the gravitational lens size.

Warp Strength

This shows you how the SgtLens component''s WarpStrength setting can adjust the maximum angle light can bend around.

Hole Size

This shows you how the SgtLens component''s HoleSize setting can adjust the size of the event horizon.

Hole Edge

This shows you how the SgtLens component''s HoleEdge setting can adjust the thickness of the event horizon.

Black Hole

This shows you how the SgtBlackHole component can be used to render a gravitational lensing effect. This component works similar to SgtLens, but it works in screen space rather than using a cubemap. This makes it suitable for active scenes where your black hole can move, or there are objects near it. Keep in mind this effect cannot bend light backwards, and can only distort pixels on the screen. Keep in mind if you''re using URP then you must enable rendering of the Opaque Texture in your pipeline settings.

Spacetime

This shows you how to render a basic spacetime grid. This is done by making a new GameObject with the SgtSpacetime component. You can then make a child GameObject with the SgtSpacetimeMesh component. You can adjust the SgtSpacetimeMesh settings to change the size and resolution of the generated grid mesh.

Gaussian Well

This shows you how the spacetime can be deformed using a basic gaussian distribution. This is done by making a new GameObject with the SgtSpacetimeWell component, and setting its Distribution setting to Gaussian. You can then adjust its Radius and Strength settings as desired.

Orbit

This shows you how the spacetime well moves with the current GameObject position to deform the spacetime mesh underneath. In this scene the SgtRotate component is used on its parent GameObject to make it orbit around the center of the scene.

Ripple Well

This shows you how the spacetime can be deformed using a ripple distribution. This is done by making a new GameObject with the SgtSpacetimeWell component, and setting its Distribution setting to Ripple. You can then adjust its Radius, Strength, and Frequency settings as desired.

Animation

This shows you how the ripple can be animated. This is done using the SgtSpacetimeWell component''s OffsetSpeed setting.

Twist Well

This shows you how the spacetime can be deformed using a twist distribution. This is done by making a new GameObject with the SgtSpacetimeWell component, and setting its Distribution setting to Twist. You can then adjust its Radius, Strength, Frequency, and HoleSize, and HolePower settings as desired.

Animation

This shows you how the twist can be animated. This is done using the SgtSpacetimeWell component''s OffsetSpeed setting.

Pinch Well

This shows you how the spacetime can be deformed to gravitate toward the spacetime well. This is done by making a new GameObject with the SgtSpacetimeWell component, and setting its Distribution setting to Pinch. You can then adjust its Radius and Strength settings as desired.

Styles

This shows you how different styles of spacetime rendering can be achieved. This is done by making a new material with the Space Graphics Toolkit / Spacetime Additive shader, and adjusting the settings. See the documenetation for the Spacetime feature to learn what each setting does.

Star Shader

This shows you how to create a procedurally animated star. This is done using the SGT / Star shader, which is applied to the material on this sphere object.

Flow

This shows you how the shader's Flow settings can be used to make the star surface flow in different directions. This is done by setting the flow Texture, which stores the amount of flow in the alpha channel. This texture should use the equirectangular (cylindrical) projection.

Sunspots

This shows you how the shader's Sunspots settings can be used to add dark and light spots to the surface. This is done by setting the sunspots Texture, which stores the change in brightness, where gray (128) is no change, white (255) is brighter, and black (0) is darker. This texture should use the equirectangular (cylindrical) projection.

Rim

This shows you how the shader's Rim Color and Rim Power settings can be used to control how the edge of the star appears.

Box

This shows you how to render a procedurally generated starfield using a box distribution. This is done using the SgtStarfieldBox component with a material using the Space Graphics Toolkit / Starfield shader.

Offset

This shows you how the SgtStarfieldBox component''s Offset component can be used to change the starfield distribution.

Colors

This shows you how the StarColors setting can be used define a range of colors that will be randomly picked from when generating each star.

Clouds

This shows you how the StarRadiusMin/Max, MainTex, and OverrideBrightness settings can be adjusted to create clouds instead of stars.

Soft

This shows you how the starfield material''s DstBlend setting can be set to OneMinusSrcColor, which changes the way the starfield renders when many stars/clouds are overlapping to make it look smoother. Keep in mind this technique may not work in HDRP, or with HDR rendering.

PowerRGB

This shows you how the starfield material''s POWER RGB setting can be used to only color the edges of the stars, and keep the center white. This makes them look more like stars, even when they change their color.

ClampSizeMin

This shows you how the SgtStarfieldBox component''s ClampSizeMin setting can be used to fade stars out instead of scaling them when they go below a certain minimum size on screen. This reduces aliasing and improves visual quality.

Layering

This shows you how multiple starfields can be combined with different settings, giving a more interesting look.

Elliptical

This shows you how the SgtStarfieldElliptical component can be used to procedurally generate and render a starfield in the shape of an elliptical galaxy or sphere.

Symmetry

This shows you how the Symmetry setting can be used to flatten the star distribution into a disc.

Offset

This shows you how the Offset setting can be used to push stars away from the center.

Bias

This shows you how the Bias setting can be used to change the probability stars appear closer or farther away from the center.

Layering

This shows you how multiple starfields can be combined with different settings, giving a more interesting look.

Spiral

This shows you how the SgtStarfieldSpiral component can be used to procedurally generate and render a starfield in the shape of a spiral galaxy.

Rotation

This shows you how the SgtRotate component can be used to automatically rotate the spiral galaxy.

ArmCount

This shows you how the ArmCount setting can be used to change the amount of spiral arms.

Twist

This shows you how the Twist setting can be used to change the spiral arm twist rate.

ThicknessInner

This shows you how the ThicknessInner setting can be used to change the spiral arm thickness at the center.

ThicknessOuter

This shows you how the ThicknessOuter setting can be used to change the spiral arm thickness away from the center.

Layering

This shows you how multiple starfields can be combined with different settings, giving a more interesting look.

Nebula

This shows you how the SgtStarfieldNebula component can be used to procedurally generate and render a starfield in the shape of a custom SourceTex you specify. Keep in mind this texture must be marked with Read/Write Enabled.

HeightSource

This shows you how the HeightSource setting can be used to change how the stars are offset from the local XZ plane.

ScaleSource

This shows you how the ScaleSource setting can be used to change how the stars are sized based on their underlying color.

Jitter

This shows you how the Jitter setting can be used to prevent bright clusters of stars from blowing out the brightness of your starfield. Keep in mind this also causes the overall shape of your starfield to lose its sharpness.

HorizontalBrightness

This shows you how the HorizontalBrightness setting can be used to control how the starfield is lit when viewed side-on. This allows you to prevent the brightness blowing out when making flat starfields like galaxies.

Layering

This shows you how multiple starfields can be combined with different settings, giving a more interesting look.

Infinite

This shows you how the SgtStarfieldInfinite component can be used to make infinitely repeating stars around the camera.

Far

This shows you how the Far setting and SgtStarfieldInfiniteFarTex components can be used to fade stars out based on the FarRadius and FarThickness settings. This is used to hide the pop-in and pop-out of the stars as they infinitely scroll.

Warp

This shows you how the Stretch setting can be used to make the stars stretch based on the velocity of any camera with the SgtCamera component. Keep in mind when not-moving, the stretch will be 0, and thus the stars will disappear. To avoid this, this demo scene also has a non-stretched starfield with otherwise the same setting, so you can still see the stars when not moving.

Dust

This shows you how the settings can be changed to make infinitely repeating dust.

Dust Near

This shows you how the Near setting and SgtStarfieldNear components can be used to fade stars out based on the NearRadius and NearThickness settings. This is used to smoothly fade the stars when they get too close and clip into the camera.

Floating Camera

This shows you how SgtStarfieldInfinite automatically works with the Universe feature's SgtFloatingCamera component. See the Universe feature for more information.

Dome

This shows you how the SgtStarfieldDome component can be used to procedurally generate and render a starfield in the shape of a dome.

Bias

This shows you how the Bias setting can be used to place more or less stars near the horizon.

Custom

This shows you how the star data of a starfield can be manually modified. This is done by finding the SgtStarfield___ component, opening its context menu (the ⋮ button), and selecting the Make Editable Copy option. This will create a new GameObject with the SgtStarfieldCustom component, and copy all procedural star data into the Stars list, allowing you to manually modify them. Keep in mind if you modify this list from code, then you must manually call the DirtyMesh() method after.

Pulse

This shows you how the starfield material''s PULSE setting can be enabled, which causes the size of each star to pulse over time. You can control the pulse speed using the SgtStarfield___ component''s StarPulseSpeedMin/Max settings.

Multiply

This shows you how the Starfield_Multiply material can be used instead of the standard additive Starfield material. This causes anything rendered before it to darken, which can create interesting effects. Keep in mind that additive and multiply rendering results change based on draw order, so the Starfield_Multiply material''s RenderQueue setting is set to Transparent + 1 (3001) to force it to render after the base starfield. This may limit the use of this effect.

Terrain Planet

This shows you how the SgtTerrainPlanet component can be used to generate a planet mesh with dynamic LOD based on camera distance. The SgtTerrainPlanetMaterial component is added alongside it to render the mesh with a material using the Space Graphics Toolkit / Terrain Planet shader. See the Planet and Terrain feature documentation for more information on the shader settings.

Atmosphere

This shows you how the SgtTerrainSharedMaterial component can be used to render an atmosphere on top of the terrain.

Heightmap

This shows you how the SgtTerrainHeightmap component can be used to deform the dynamic planet mesh using a heightmap texture. Keep in mind this texture should use the equirectangular cylindrical mapping.

Simplex

This shows you how the SgtTerrainSimplex component can be used to add procedural heights to the terrain. Fly down to the surface to see it in action.

Collider

This shows you how the SgtTerrainCollider component can be used to generate MeshColliders on the terrain when the camera approaches the surface. You can control the Detail of the generated collider to alter how many triangles each MeshCollider is given. You can also control the Resolution, allowing you to adjust the overall side of each MeshCollider.

Spawner

This shows you how the SgtTerrainPrefabSpawner component can be used to procedurally spawn prefabs on the terrain as the camera approaches. This gives you control over the maximum amount (Limit), their orientation (Rotate), and the Prefabs list that will be randomly picked from.

Areas

This shows you how the SgtTerrainPlanet.Areas setting can be used to define different areas on the planet surface. Components like SgtTerrainSimplex and SgtTerrainPrefabSpawner can then use the Area setting to lock themselves to these area. These areas are defined using the SgtTerrainSplatmap asset, which takes an input color texture, and allows you to associate different colors with different areas by name. You can duplicate the example asset to make your own.

Feature

This shows you how the SgtTerrainFeature component can be used to deform a specific area of the planet using a custom heightmap texture.

Terrain Ocean

This shows you how to add a layer of ocean to your terrain planet. This is done by making a new GameObject, and adding the SgtTerrainOcean and SgtTerrainOceanMaterial components. This should be rendered with a material that uses the Space Graphics Toolkit / Terrain Ocean shader (see documentation for more details). Keep in mind the ocean requires your camera(s) to render a Depth Texture, which can be enabled by adding the SgtDepthTextureMode component to them.

Atmosphere

This shows you how the SgtTerrainSharedMaterial component can be added to both the terrain and the ocean GameObjects, allowing the atmosphere to render on top of them.

Depth Color

This shows you how the ocean material''s DEPTH COLOR settings can be used to change the color of the ocean as it approaches the shoreline.

Detail

This shows you how the ocean material''s BAKED DETAIL settings can be enabled, allowing you to add up to 3 layers of detail to your ocean. The tiling of each detail level can be adjusted using the SgtTerrainOcean component''s BakeDetailTilingA/B/C settings. Each detail layer also has the Fade Range setting, which can be used to hide the previous layer as you approach the next layer.

Animation

This shows you how the SgtTerrainOceanMaterial component''s Animate setting can be enabled. This will animate the ocean detail textures over time to make the surface look more interesting. The Detail A/B/C settings can be used to control which detail layers are modified.

Waves

This shows you how the ocean material''s WAVES settings can be used to add animated waves to the shoreline of the ocean. See the documentation for the Terrain feature for more information of the wave settings.

Shore

This shows you how the planet material''s SHORE settings can be used to add beaches to the shoreline of the terrain. See the documentation for the Terrain feature for more information of the wave settings.

Underwater

This shows you how to render the ocean underwater. This is done by duplicating the ocean GameObject, and enabling the SgtTerrainOcean component''s Invert setting.

Underwater Atmosphere

This shows you how to make an underwater-only atmosphere. This is done by duplicating the atmosphere GameObject with different settings, and removing the SgtAtmosphere component''s OuterMesh setting. You can then drag and drop this into the underwater ocean''s SgtTerrainSharedMaterial.SharedMaterial setting. The SgtTerrainUnderwater component can then be used to swap the planet''s terrain atmosphere material to the underwater version when the camera goes underwater.

Basic Thruster

This shows you how to turn a normal sprite into a thruster using the SgtThruster, SgtThrusterScale, and SgtThrusterRoll components. The SGT Thruster shader/material is also used to make the sprite glow.

Controls

This shows you how the SgtThrusterControls component can be used to set the SgtThruster.Throttle value using input axes.

Camera

This shows you how to make a basic scene with the SgtCameraMove and SgtCameraLook components. This works well for small scenes, but if the camera moves too far away then movement begins to break down, as well as rendering, physics, etc.

Floating Camera

This shows you how the SgtFloatingCamera component can be added to the camera, causing its position to snap back to 0,0,0 when it moves too far away. The cumulative camera position is still stored in this component, so you can still have accurate positioning very far away (e.g. even lightyears away).

Floating Object

This shows you how the SgtFloatingObject component can be added to the asteroid, allowing its position to update each time the camera position snaps. And that''s it, your scene now implements the Universe feature. If you want to accurately position objects very far away then I recommend you adjust the LocalX/Y/Z values, which give you higher precision than Transform.position, and won''t change when the camera position snaps.

Floating Speedometer

This shows you how the SgtFloatingSpeedometer component can track the speed of a SgtFloatingCamera or SgtFloatingObject component, and display the speed to a UI Text element.

Floating Orbit

This shows you how the SgtFloatingOrbit component can be added to the asteroid. The ParentPoint setting is used to make it orbit around the star.

Floating Orbit Visual

This shows you how the SgtFloatingOrbitVisual component can be used to draw a visual ring of the orbit. Make sure you set this component in the SgtFloatingOrbit.Visual field too.

Floating Spawner (Sphere)

This shows you how the SgtFloatingSpawnerSphere component can be added alongside your SgtFloatingObject component. When the SgtFloatingCamera gets within your specified Range, it will spawn the prefabs you specify using a sphere distribution.

Floating Spawner (Ring)

This shows you how the SgtFloatingSpawnerRing component can be added alongside your SgtFloatingObject component. When the SgtFloatingCamera gets within your specified Range, it will spawn the prefabs you specify using a ring distribution.

Floating Spawner (Orbit)

This shows you how the SgtFloatingSpawnerOrbit component can be added alongside your SgtFloatingObject component. When the SgtFloatingCamera gets within your specified Range, it will spawn the prefabs you specify in orbit.

Floating Root

This shows you how the SgtFloatingRoot component can be added to your scene. All spawned prefabs will be placed under this GameObject to improve organization.

Floating Warp

This shows you how you can tap objects on the screen and warp to them. The tapping is handled by the SgtFloatingWarpPin component in the Canvas/Pin GameObject, which picks any GameObject with the SgtFloatingTarget component attached. The warping is then handled by the SgtWarpSmoothstep component.

Floating Scaler

This shows you how the SgtFloatingScaler component (Right) can be used to reduce the rate at which distant objects shrink. Using a fixed scale (Left) works well for solid objects, but for glowing stars it can quickly lead to them becoming too small to see.

Star Cluster

This shows you how the SgtFloatingSpawnerSphere component can be used to spawn stars that can be warped to. This scene uses realistic distances, with all 100 stars spawning within a radius of 2 lightyears, and a warp distance of 100 AU.

Nested Spawner

This shows you how the SgtFloatingSpawner___ component can be nested, allowing the stars to spawn planets when you get close enough.

Nested Orbits

This shows you how the SgtFloatingSpawner___ component can be nested, allowing the stars to spawn planets when you get close enough.

Third Person

This shows you how to create a third person camera system using the Universe feature. This is done by placing the SgtFloatingCamera component on the camera parent orbit point. The warp is performed on the Rocket Ship''s SgtFloatingObject rather than the camera, and the camera pivot point is made to follow the Rocket Ship using the SgtFloatingFollow component.

Floating Massive

This shows you how to simulate massive distant objects in space (e.g. galaxies). You can't use the SgtFloatingObject to render these, because Unity's rendering breaks down beyond a certain size and/or distance. To work around this, you must instead use the SgtFloatingMassive component. This component scales and positions the object to make it appear as if it's incredibly distant and massive, but it's actually brought closer to prevent any issues. This component works like SgtFloatingObject, but it takes over the Transform component, and doesn't allow you to manually move it (e.g. no Rigidbody).

Astrophysical Jet

This shows you how the Accretion, Flare, and Prominence features can be combined to create an animated accretion disk with astrophysical jets shooting from the poles.

Earth Sized Planet

This shows you how the Terrain and Universe features can be combined to render a planet with the same radius as Earth.

Elliptical Galaxy

This shows you how to make a nebula scene by combining the Starfield Spiral and Backdrop features.

Gravitational Waves

This shows you how the Spacetime and Singularity can be combined to create an animated gravitational wave ripple effect

Jovian

This shows you how the Jovian and Aurora features can be combined. These are both transparent effects, which normally can''t be combined with correct depth ordering. To fix this, you can enable the ZTest setting in the Jovian''s material, which will add depth to the jovian, allowing the aurora to render correctly around the jovian.

Nebula

This shows you how to make a nebula scene by combining the Starfield Nebula, Billboard and Backdrop features.

Obsidian Planet

This shows you how the Earth Sized Planet demo scene can be modified to create a different style of planet.

Planet Surfing

This shows you how the SgtTerrainObject component can be used to keep an object glued to the surface of a planet. This object can then be moved around using the Thruster features.

Space Probe

This shows you how the SgtThruster, SgtThrusterScale, and SgtThrusterRoll components can be combined to make a simple flickering thruster effect.

Spiral Galaxy

This shows you how to make a nebula scene by combining the Starfield Spiral and Backdrop features.

Storm Planet

This shows you how the SgtLightningSpawner component can procedurally spawn animated lightning around your planets.

Vortex

This shows you how the Prominence feature can be used to create an animated vortex effect.

VR Stars

This shows you how the SgtStarfieldElliptical component can be layered many times with different radius and distance settings, to give an impressive feel in VR with stars at varying depths.

Water Level

This shows you how the SgtStaticPlanet component's WaterHeight value can be controlled from a UI slider.

Atmosphere Shader

The SgtAtmosphere component is rendered using a material that uses the Space Graphics Toolkit/Atmosphere shader. Here are what its settings do:

Inner Depth Tex

The DepthTex applied to the inner mesh (surface).

Outer Depth Tex

The DepthTex applied to the outer mesh (sky).

LIGHTING

This allows the atmosphere to receive light and shadows using the SGT custom lighting model.

LIGHTING / Ambient Color

This allows you set the ambient light color when no other lights are shining on the atmosphere.

LIGHTING / Lighting Tex

The lookup table for the lighting gradient.

LIGHTING SCATTERING

This allows the atmosphere lighting calculations to include atmospheric scattering, which adds a halo/glow around the light sources.

LIGHTING SCATTERING / Scattering Terms

The allows you to set up to 4 different layers of atmospheric scattering. Each value allows you to control the size of the halo/glow around each light source, where a higher value means a smaller radius.

LIGHTING SCATTERING / Scattering Strengths

This allows you to set the strength/brightness for each of the 4 scattering layers set above. Setting one to 0 will disable that scattering layer.

LIGHTING SCATTERING / Scattering Tex

The lookup table for the scattering gradient.

LIGHTING SCATTERING HDR

This allows the atmosphere scattering calculations to exceed the normal 0..1 (0..255) range, making it suitable for HDR rendering. If your project uses HDR camera rendering, then you should enable this.

Aurora Shader

The SgtAurora component is rendered using a material that uses the Space Graphics Toolkit/Aurora shader. Here are what its settings do:

Main Tex

The MainTex applied to the aurora ribbons.

NEAR FADE

This allows the aurora to fade out as the camera approaches.

NEAR FADE / Near Range Recip

This allows you set the reciprocal of the world space distance where the fade will begin.

NEAR FADE / Near Tex

The lookup table for the fade gradient.

ANIMATION

This allows the aurora ribbons to animate over time.

ANIMATION / Anim Speed

This allows you to set how fast the aurora animates.

Backdrop Shader

The SgtBackdrop component is rendered using a material that uses the Space Graphics Toolkit/Backdrop shader. Here are what its settings do:

POWER RGB

Normally the color of each backdrop billboard will be multiplied by the billboard texture, which gives it color. However, this setting causes the RGB values to instead get raised to the power of its color. If your billboards have a star texture, then this causes only the edges of the star to get colored, keeping the center white. This makes it suitable for rendering stars.

POWER RGB / Color Influence

This allows you to control how powerful the color tinting applies to the billboard texture.

Belt Shader

The SgtBelt component is rendered using a material that uses the Space Graphics Toolkit/Belt shader. Here are what its settings do:

LIGHTING

This allows the belt to receive light and shadows using the SGT custom lighting model.

LIGHTING / Ambient Color

This allows you set the ambient light color when no other lights are shining on the belt.

LIGHTING / Lighting Tex

The lookup table for the lighting gradient.

Sprite Billboard Flares

Light sources in Unity are only visible when they shine on objects. This means it can be hard to see where they are when you're in space. To make

it clear where your lights are, you can use flares to give them a nice looking visual.

SGT comes with several components and materials that allow you to make impressive flared using billboards. A billboard is a flat mesh (e.g. quad or sprite) that rotates toward the camera.

Add a Billboard

To add a billboard to your scene, drag and drop a sprite from your Project tab into the Hierarchy tab.

For example, the Space Graphics Toolkit\Features\Shared\Examples\Textures\Billboard1 sprite can be used.

Your scene should now contain a new GameObject with the SpriteRenderer component.

To turn this sprite into a billboard, simply add the SgtBillboard component. I also recommend you enable the Avoid Clipping setting.

You can now play your scene and your billboard should always face the camera.

Make it Glow

By default, sprites in Unity use the default sprite shader, which uses alpha blending.

To make them glow, you need to use a shader that uses additive blending. Simply change the Sprite Renderer component's Materialsetting

to the Billboard material that comes with SGT.

Make it Glow Even More

The billboard you just created is a good start, but to make your flare look more impressive you should add a second layer.

To do this, drag and drop another sprite onto the sprite GameObject you created earlier. This will add a new sprite as a child of your existing sprite.

You then need to change the material on your new flare. But this time, you should choose the Billboard Overlay material. This material will force your second flare layer to render on top of everything.

Make it Glow Less

You may notice the second billboard layer you added looks great from some angles, but it shines through all foreground objects (e.g. planets), which makes it look bad.

To fix this, add the SgtOcclusionScaler component to your second billboard layer. This component will shrink the current GameObject if the line of sight between the camera and the flare is blocked by a collider, or by components like SgtJovian and SgtAtmosphere that implement their own custom occlusion code.

If you play your game, your first light flare should always be visible and look the same, and your second layer should now grow and shrink based on what's in front.

Cloudsphere Shader

The SgtCloudsphere component is rendered using a material that uses the Space Graphics Toolkit/Cloudsphere shader. Here are what its settings do:

Cull

You can use this setting to make the cloudsphere render outside to space (back), or inside to the ground (front).

Depth Tex

The lookup table for the optical depth gradient.

NEAR FADE

This allows the cloudsphere to fade out as the camera approaches.

NEAR FADE / Near Range Recip

This allows you set the reciprocal of the world space distance where the fade will begin.

NEAR FADE / Near Tex

The lookup table for the fade gradient.

DETAIL

This allows you to enhance the detail of the cloudsphere's base texture.

DETAIL / Detail Strength

This allows you to control how much the detail texture will influence the base texture's opacity.

DETAIL / Detail Tiling

The detail texture will be tiled this many times around the cloudsphere.

DETAIL / Detail Tex

The detail texture.

LIGHTING

This allows the cloudsphere to receive light and shadows using the SGT custom lighting model.

LIGHTING / Ambient Color

This allows you set the ambient light color when no other lights are shining on the cloudsphere.

LIGHTING / Lighting Tex

The lookup table for the lighting gradient.

Debris Spawner

The SgtDebrisSpawner component implements gradual spawning of debris over time with random positions, making this approach perfect for moving debris (e.g. asteroids you can interact with).

The main limitation of this debris spawning approach is that there is no persistence of debris data, meaning returning to the same location will give you new asteroid positions.

Debris Grid

The SgtDebrisGrid component implements debris spawning where the positions are procedurally chosen. This approach is ideal if you want a consistent distribution of static debris that look the same when returning to the same location.

One thing you should keep in mind when using this approach is that debris spawning performance is proportional to your camera movement speed.

Flare Shader

The SgtFlare component is rendered using a material that uses the Space Graphics Toolkit/Flare shader. Here are what its settings do:

Color

The overall flare will be tinted by this color.

Brightness

The Color.rgb values will be multiplied by this before use.

DstBlend

This allows you to control the DstBlend portion of the blending mode. By default this is set to One, for additive blending. However, this can be set to OneMinusSrcColor, which makes the blending smoother.

ZTest

This allows you to control how the flare appears relative to other opaque objects in the scene.

If this is set to LEqual then it will behave like any other transparent object and get occluded by solid objects in front.

If this is set to Always then it will render on top of all opaque objects.

Main Tex

The color gradient texture applied to the flare.

Galaxy Shader

The SgtGalaxy component is rendered using a material that uses the Space Graphics Toolkit/Galaxy shader. Here are what its settings do:

Tint

The base galaxy will be tinted by this color.

Color Shift

The base galaxy colors will be hue shifted by this angle.

RIM / Min

The edges of the galaxy effect will fade out. This allows you to specify how soon the dark parts of the galaxy will fade out.

RIM / Max

The edges of the galaxy effect will fade out. This allows you to specify how soon the light parts of the galaxy will fade out.

BASE / Texture

The base galaxy texture. This can be based on a satellite image.

BASE / Scale

The galaxy texture will be zoomed in or out by this amount.

BASE / Blend (XY)

This allows you to set the transition size and sharpness along the edge of the galaxy.

STARS

If you enable this then the galaxy will be overlaid with a layer of stars.

STARS / Mask (A)

This allows you to specify where the stars should appear on the galaxy. This should match the shape of the base texture.

STARS / Texture

This allows you to specify the stars texture.

STARS / Tiling

The star texture will be tiled this many times across the galaxy.

STARS / Bias

The higher you set this, the fewer stars will appear in darker areas of the stars mask texture.

STARS / Strength

This allows you to control the final brightness of the stars.

DUST

If you enable this then the galaxy will be overlaid with a spiral of dark dust clouds.

DUST / Texture (A)

This allows you to specify the dust texture.

DUST / Tiling

The dust texture will be tiled around the galaxy this many times.

DUST / Scale

The dust texture will be tiled in/out of the galaxy this many times.

DUST / Twist

This allows you set how much the dust texture twists around the galaxy.

DUST / Bias

This allows you to make the twist rate different at the core of the galaxy compared to the outer edge.

DUST / Alpha Offset

This allows you to fade out the dust near the center of the galaxy.

DUST / Alpha Power

This allows you to control how quickly the dust near the center of the galaxy fades out.

DUST / Color

This allows you to control the dust color near the center of the galaxy.

DUST / Color Power

This allows you to control how quickly the dust color near the center of the galaxy fades to black toward the edge.

NEAR FADE

This allows the galaxy to fade out as the camera approaches.

NEAR FADE / Near Range Recip

This allows you set the reciprocal of the world space distance where the fade will begin.

For example, if you want a fade distance of 100 units, then you would set 1/100 or 0.01.

NEAR FADE / Near Tex

The lookup table for the fade gradient.

Jovian Shader

The SgtJovian component is rendered using a material that uses the Space Graphics Toolkit/Jovian shader. Here are what its settings do:

ZWrite

By default, transparent objects like the jovian don't write to the depth buffer. However, if you have a transparent effect around it like the Aurora, then you need to enable this so that the aurora behind the planet get masked out.

Depth Tex

The lookup table for the optical depth gradient.

Noise Tex (A)

The flow texture will be offset by this.

LIGHTING

This allows the jovian to receive light and shadows using the SGT custom lighting model.

LIGHTING / Ambient Color

This allows you set the ambient light color when no other lights are shining on the jovian.

LIGHTING / Lighting Tex

The lookup table for the lighting gradient.

LIGHTING SCATTERING

This allows the atmosphere lighting calculations to include atmospheric scattering, which adds a halo/glow around the light sources.

LIGHTING SCATTERING / Scattering Terms

The allows you to set up to 4 different layers of atmospheric scattering. Each value allows you to control the size of the halo/glow around each light source, where a higher value means a smaller radius.

LIGHTING SCATTERING / Scattering Strengths

This allows you to set the strength/brightness for each of the 4 scattering layers set above. Setting one to 0 will disable that scattering layer.

LIGHTING SCATTERING / Scattering Tex

The lookup table for the scattering gradient.

FLOW

This allows the jovian texture to be distorted using a flow map.

FLOW / Flow Speed

The flow map will animate at this speed.

FLOW / Flow Strength

The flow map will be allowed to distort the UV by this amount.

FLOW / Flow Noise Tiling

This allows you to set the frequency of the noise used to offset the flow map timing to make it look less uniform.

Texture Format

The lightning texture animation is stored using the RGB pixels in a specific way.

The Red channel is used to store the overall shape of the lightning. This works similarly to texture opacity.

The Green channel is used to store when that pixel should appear during the animation.

The Blue channel is used to store when that pixel should disappear during the animation.

Since the Green and Blue channels define the start and end of the animation respectively, the blue channel should always be brighter than the green channel for each individual pixel.

Nebula Shader

The SgtNebula component is rendered using a material that uses the Space Graphics Toolkit/Nebula shader. Here are what its settings do:

Tint

The base galaxy will be tinted by this color.

Color Shift

The base galaxy colors will be hue shifted by this angle.

TEXTURE / Texture

This is the base nebula texture.

TEXTURE / Scale

This allows you to set the amount of texture tiling.

TEXTURE / Blend (XY)

This allows you to set the transition size and sharpness along each edge.

TEXTURE / Jitter

This allows you to set how far the texture on each side of the nebula will be randomly offset from the center.

DETAIL

If you enable this then the nebula will be overlaid with a layer of detail.

STARS / Texture (A)

This allows you to specify the detail texture, where the detail is stored in the alpha channel.

STARS / Tiling

The detail texture will be tiled this many times across the galaxy.

STARS / Bias

This allows you to adjust the contrast of the detail texture.

STARS / Strength

This allows you to control the final brightness of the detail.

RIM / Min

The edges of the nebula effect will fade out. This allows you to specify how soon the dark parts of the nebula will fade out.

RIM / Max

The edges of the nebula effect will fade out. This allows you to specify how soon the light parts of the nebula will fade out.

NEAR FADE

This allows the nebula to fade out as the camera approaches.

NEAR FADE / Near Range Recip

This allows you set the reciprocal of the world space distance where the fade will begin.

For example, if you want a fade distance of 100 units, then you would set 1/100 or 0.01.

NEAR FADE / Near Tex

The lookup table for the fade gradient.

Planet Shader

This shader allows you to render high quality planets. You can access it by making a new material, and selecting the Space Graphics Toolkit/Planet shader.

Color

This allows you to tint the terrain color.

Metallic

This allows you to control the PBR metallic setting of the whole planet (usually 0).

Smoothness

This allows you control the PBR smoothness of the whole planet (usually 1).

Normal Strength

This allows you to dampen or strengthen the normal map set below.

Albedo Shift

This setting allows you to rotate the

Albedo (RGB) Smoothness (A)

This is the main texture, where the albedo color is stored in the RGB channels, and the PBR Smoothness is stored in the alpha channel.

This texture should use equirectangular (cylindrical) projection, and have Wrap Mode = Repeat on the U axis.

Normal

This is the normal map. This should match the albedo mapping.

Height (A)

This is the height map, where the height is stored in the alpha channel.

SHARED / Detail R/G/B/A

This allows you to specify how many detail types should appear on each delay layer. The location of these detail types can be controlled using the mask map below.

SHARED / Detail Mask (RGBA)

This allows you to control where the detail textures are applied on your planet. This should match the albedo mapping.

SHARED / Noise Texture (A)

This is used to break up the repetition of the detail textures.

SHARED / Albedo Enabled

This allows you to enable albedo detail mapping for all detail layers.

SHARED / Albedo R/G/B/A

This allows you to set the seamless albedo texture used for each detail layer.

SHARED / Normal Enabled

This allows you to enable normal detail mapping for all detail layers.

SHARED / Normal R/G/B/A

This allows you to set the normal map used for each map in this layer.

DETAIL / Enabled

This will add a detail map layer to your planet, making it look higher resolution up close.

DETAIL / Tiling

This allows you control the amount of times this detail texture is tiled along around the planet.

DETAIL / Fade Range

If the camera goes below this distance to the surface then it will begin to fade out. This is useful because having multiple detail levels visible at the same time can look overwhelming.

DETAIL / Fade Bound

If the camera goes beyond this distance to the surface then it will begin to fade out. This is useful because having multiple detail levels visible at the same time can look overwhelming.

DETAIL / Strength R/G/B/A

The allows you to set the overall albedo and/or normal map strength for this layer.

NIGHT

This allows you to add night lights to your planet.

NIGHT / Sharpness

This allows you to control how sharp the transition between no night lights and full night lights is.

NIGHT / Offset

This allows you to control how far into the light side the night lights will appear.

NIGHT / Texture (RGB)

This is the emissive texture used for rendering the night side of the planet. This should match the albedo mapping.

WATER

This allows you to render water on the planet surface.

WATER / Tiling

This allows you to set the amount of times the water texture is tiled around the planet.

WATER / Metallic

This allows you to set the PBR metallic of the water (usually 0)

WATER / Smoothness

This allows you to set the PBR smoothness of the water (usually 1)

WATER / Emission

This allows you to set the brightness of the water. This is useful if you want lava to glow.

WATER / Coast Sharpness

This allows you to set how quickly the water hides the underwater terrain.

SgtPlanet Component

The SgtPlanet component allows you to render a planet using the specified mesh and material that the SGT / Planet shader.

While it's possible to manually render a planet with the MeshFilter and MeshRenderer components, the SgtPlanet component also adds additional UV data to the mesh so it can seamlessly tile detail textures around the surface without polar distortion.

For further information I recommend you go through the demo scenes in the Planet feature folder.

SgtPlanetWaterGradient Component

If your planet material has water enabled, then you should add this component so you can control the water color based on the ocean depth.

SgtPlanetWaterTexture Component

If your planet material has water enabled, then you should add this component so you can control the water normal texture, and this component will also handle its animation.

Prominence Shader

The SgtProminence component is rendered using a material that uses the Space Graphics Toolkit/Prominence shader. Here are what its settings do:

FADE EDGE

This setting fades out all prominence planes that are parallel to the camera's view angle.

FADE EDGE / Fade Power

This controls how quickly the planes fade out based on their angle relative to the camera's view.

CLIP NEAR

This setting fades out all prominence planes when they're in front of the star/planet they're rendered on top of.

CLIP NEAR / Clip Power

This controls how quickly the planes fade out based on their position relative to their center point.

DISTORT

This causes the prominence plane's UV to shift over time to make them look like a flickering flame.

DISTORT / Distort Scale (XY)

This controls the texture tiling.

DISTORT / Distort Speed (XY)

This controls the texture animation speed.

DISTORT / Distort Strength

The controls the strength of the UV displacement.

DISTORT / Distort Tex (A)

DETAIL

This applies a layer of detail to the prominence plane.

DETAIL / Detail Scale (XY)

This controls the texture tiling.

DETAIL / Detail Speed (XY)

This controls the texture animation speed.

DETAIL / Detail Strength

The controls the strength of the opacity modification of the base texture.

DETAIL / Detail Tex (A)

This allows you to specify the detail texture.

Ring Shader

The SgtRing component is rendered using a material that uses the Space Graphics Toolkit/Ring shader. Here are what its settings do:

Tiling

The ring texture will be tiled this many times around the circumference of the ring.

NEAR FADE

This allows the ring to fade out as the camera approaches.

NEAR FADE / Near Range Recip

This allows you set the reciprocal of the world space distance where the fade will begin.

NEAR FADE / Near Tex

The lookup table for the fade gradient.

DETAIL

This applies a layer of detail to the ring. The Mode setting should be set to Color for an accretion disk, and Alpha for a planetary ring.

DETAIL / Detail Tiling (XY)

This controls how many times the detail texture is tiled around the ring.

DETAIL / Detail Speed (XY)

This controls the texture animation speed.

DETAIL / Detail Twist

If you want the detail tiling to be different between the inner and outer parts of the ring, you can set the amount of twisting here.

DETAIL / Detail Twist Bias

This allows you to control if the twisting should be uniform, or isolated to the inner ring.

DETAIL / Detail Tex

This allows you to specify the detail texture.

LIGHTING

This allows the ring to receive light and shadows using the SGT custom lighting model.

LIGHTING / Ambient Color

This allows you set the ambient light color when no other lights are shining on the ring.

LIGHTING / Lighting Tex

The lookup table for the lighting gradient.

LIGHTING SCATTERING

This allows the atmosphere lighting calculations to include atmospheric scattering, which adds a halo/glow around the light sources.

LIGHTING SCATTERING / Scattering Terms

The allows you to set up to 4 different layers of atmospheric scattering. Each value allows you to control the size of the halo/glow around each light source, where a higher value means a smaller radius.

LIGHTING SCATTERING / Scattering Strengths

This allows you to set the strength/brightness for each of the 4 scattering layers set above. Setting one to 0 will disable that scattering layer.

LIGHTING SCATTERING / Scattering Tex

The lookup table for the scattering gradient.

Black Hole

The SgtSingularity component is a screen space (camera) effect, which means it can run fast and give consistent quality, but it can't warp pixels that are off screen (e.g. behind the camera).

Lens

The SgtLens component is a world space (cubemap) effect, which means it's slow to update, but it can render very quickly, and it can warp pixels in any direction, including behind the camera.

Step 1 - Make a Spacetime

You should now see the SgtSpacetime component in your inspector tab.

Step 2 - Make a Mesh

For the spacetime effect to render, you need to make a mesh that it will be displayed on. This mesh will be deformed by gravitational bodies by modifying vertex positions, so for best results you should use a high resolution grid mesh. You can use any mesh for this (including Unity's built-in Plane mesh), but SGT comes with a component to generate this mesh for you. To use it:

You should now see the SgtSpacetimeMesh component in your inspector tab. Feel free to adjust the SizeX/Z and QuadsX/Z settings to your desire.

Step 3 - Add Wells

To make the spacetime effect display curvature, you need to add gravitational wells. To do this:

You should now see the SgtSpacetimeWell component in your inspector tab.

Step 4 - Done!

You now have a basic spacetime set up. To show the spacetime curvature of planets and such, just add the Spacetime Well as a child to your planet, and watch it deform the grid as it moves.

Spacetime Shader

By default, all spacetimes use the "Spacetime (Default)" material, which has basic rendering settings for the spacetime effect.

To create your own, either make a new material with the Space Graphics Toolkit / Spactime Additive material, or duplicate one of the example ones. Then drag and drop it into the SgtSpacetime component's Material setting.

Coord

This allows you to control the source of the grid UV coordinates. Either using the Mesh UV data, or from world space coordinates.

Tiling

This allows you to control how often the grid texture appears.

Proximity

This allows you to control how far from a spacetime well the PROXIMITY COLOR setting appears. For example, if you set this to 2 and your well has a radius of 2 units, then the proximity colors will begin from 4 units away.

WARP / Mode

This allows you to control how the spacetime wells will deform the spacetime mesh. Either by offsetting them in a fixed direction (e.g. down), or attracting them toward the well to create a 'pinch' effect.

WARP / Offset Vector

If you've setWARP / Mode to Offset, then this allows you to specify the world space offset a well will give when its strength is 1.

WARP / Pinch Power

If you've setWARP / Mode to Pinch, then this allows you to specify the overall strength of the pinch effect relative to each well's Strength setting.

BASE COLOR / Color

The spacetime will initially be given this color.

BASE COLOR / Brightness

The color value will be multiplied by this.

BASE COLOR / Albedo (RGB)

The color value will be multiplied by this.

WARP COLOR

These settings work the same as the BASE COLOR settings, but will appear based on the strength of the spacetime well at the current point.

PROXIMITY COLOR

These settings work the same as the BASE COLOR settings, but will appear based on the distance to the current spacetime well relative to its radius, and the Proximity setting.

Star Shader

This shader allows you to render high quality planets. You can access it by making a new material, and selecting the Space Graphics Toolkit/Star shader.

Color

This allows you to control the base color of the star.

Brightness

The Color value will be multiplied by this. This allows you to easily adjust the overall brightness.

Noise Warp

If you specify a Texture below, then it will be deformed based on the procedural noise. This should typically use low values like 0.001.

Texture (RGB)

This is the main texture, where the star colors are stored in the RGB channels.

RIM / Color

This allows you to set the color around the edge of the star surface.

RIM / Power

This allows you to control the rim color falloff/distribution, where a higher value pushes the rim color closer to the edges.

NOISE / Channels

This allows you to specify which color channels the noise will modify. Noise adds and subtracts from the color, so a white color means red green and blue will be modified equally.

NOISE / Strength

This allows you to control the overall contrast of the noise.

NOISE / Tile

This allows you to control the frequency of the noise.

NOISE / Speed

This allows you to control the animation speed of the noise.

NOISE / Octaves

This allows you to control the detail of the noise.

FLOW / Strength

If you specify a FLOW / Texture (A), then this controls its overall strength.

FLOW / Texture (A)

This texture improves the appearance of the star surface by offsetting the noise timing, and with high strength values it can give the surface the appearance of flowing.

SUNSPOTS / Color

This allows you to control the color of the sunspots.

SUNSPOTS / Strength

This allows you to control the overall influence of the sunspots on the final star surface.

SUNSPOTS / Noise Warp

If you specify a Texture below, then it will be deformed based on the procedural noise. This should typically use low values like 0.001.

SUNSPOTS / Texture (A)

This allows you to set where on the surface dark and bright sunspots are. Gray values (128) mean there is no sunspots, and the color will not be modified. Black values (0) mean there is a dark sunspot. White values (255) mean there is a bright sunspot.

OTHER / Noise Texture (RG)

This is the look up table for the noise. You should leave this as-is.

For further information I recommend you go through the demo scenes in the Planet feature folder.

Starfield Shader

The SgtRing component is rendered using a material that uses the Space Graphics Toolkit/Ring shader. Here are what its settings do:

DstBlend

This allows you to control the DstBlend portion of the blending mode. By default this is set to One, for additive blending. However, this can be set to OneMinusSrcColor, which makes the blending smoother.

NEAR FADE

This allows the starfield to fade out as the camera approaches.

NEAR FADE / Near Range Recip

This allows you set the reciprocal of the world space distance where the fade will begin.

NEAR FADE / Near Tex

The lookup table for the fade gradient.

FAR FADE

This allows the starfield to fade out if the camera goes too far away.

FAR FADE / Far Radius

This allows you set the world space distance where the fade will begin.

FAR FADE / Far Range Recip

This allows you set the reciprocal of the world space thickness of the fade region.

FAR FADE / Far Tex

The lookup table for the fade gradient.

Basic Setup

Begin by creating a terrain planet.

Your scene should now contain a selected GameObject with the SgtTerrainPlanet and SgtTerrainPlanetMaterial components.

You can now set the SgtTerrainPlanetMaterial component's Material setting.

Terrain Planet Shader

The terrain feature comes with the SGT / Terrain Planet shader, which is specifically designed to be used with the SgtTerrainPlanet component. This shader works similarly to the SGT / Planet shader, so I recommend you read the documentation for that first.

The main difference is the DETAIL layers no longer have the Tiling. Instead, you must specify the tiling in the SgtTerrainPlanet component's BakedDetailTilingA/B/C settings. This bakes the tiling into the terrain mesh, which allows for much higher resolution detail textures than would be possible from shader settings alone.

SHORE / Mask (A)

This allows you to optionally specify where the beach around the shore should appear. This texture should match the mapping of the planet surface albedo/normal/etc textures.

SHORE / Albedo (RGB)

This allows you to specify the albedo detail texture applied to the beach.

SHORE / Detail

This allows you to specify which layer of detail the detail texture will be applied to.

SHORE / Range

This allows you to specify the world space height above the water level that the beach will appear.

SHORE / Noise Tiling

This allows you to increase the detail tiling relative to the underlying noise tiling.

SGT Terrain Ocean Shader

The terrain feature comes with the SGT / Terrain Ocean shader, which is specifically designed to be used with the SgtTerrainOcean and SgtTerrainOceanMaterial components to render an ocean. This shader works similarly to the SGT / Terrain Planet shader, so I recommend you experiment with that first.

DEPTH COLOR / Range

This allows you to specify the depth at which the ocean color will reach the color you specify below.

DEPTH COLOR / Power

This allows you to control how sharp the transition between the deep ocean and shore color is.

DEPTH COLOR / Color

This allows you to control the color of the deep ocean.

TRANSPARENCY / Mode = Vertical

The ocean will be given transparency based on the vertical depth between the water surface and ground surface.

TRANSPARENCY / Mode = Depth

The ocean will be given transparency based on the distance between the camera depth texture and the ground surface.

TRANSPARENCY / Range

This allows you to change how deep into the ocean you can see in meters.

TRANSPARENCY / Power

This allows you to change how quickly the ocean occludes based on its depth, where a higher value means it's harder to see through until the depth gets quite low.

TRANSPARENCY / Depth Scale

This allows you to change how quickly the ocean occludes based on its depth, where a higher value means it's harder to see through until the depth gets quite low.

TRANSPARENCY / Fresnel

This allows you to boost the opacity of the ocean when viewed at shallow angles. This is used to hide depth texture issues when using large planets.

REFRACTION / Enabled

This allows you to enable refraction that causes the terrain seen through the water surface to be distorted.

REFRACTION / Strength

This allows you to control the overall refraction distortion strength.

SHORE / Fade Range

This works similarly to the TRANSPARENCY / Range setting as a second layer. This allows you to fade the shore out abruptly to avoid sharp transitions at the shoreline.

SHORE / Mask (A)

This allows you to optionally specify where the waves on the shore should appear. This texture should match the mapping of the planet surface albedo/normal/etc textures.

WAVES

This adds a basic animated wave effect to the shorelines of the planet.

WAVES / Blend

This allows you to control how the wave color will blend into the underlying ocean color.

WAVES / Opacity (A)

This allows you to specify the opacity map of the waves. The bottom of the texture is the front of the wave, the top of the texture is the back of the wave. The left side of the texture is used when the wave is in deep water, and the right side of the texture is used when approaching the shore.

WAVES / Color

This allows you to change the overall color of the waves.

WAVES / Range

This allows you to set the maximum local space depth from where waves can appear.

WAVES / Interval

This allows you to set the amount of waves within the wave range.

WAVES / Speed

This allows you to set the animation speed of the waves.

WAVES / Noise Tiling

This allows you to set the resolution of the noise that will break up the waves to make them look more interesting.

Heightmap

If you want your terrain to be deformed using a pre-designed global heightmap, then you can use the SgtTerrainHeightmap component. Simply add this to your terrain GameObject, and set its Heightmap setting to the heightmap texture you want.

This heightmap texture must use the equirectangular cylindrical projection, and a pixel of 0 means no height, and 255 means maximum height. You can control the overall height scaling using the Displacement setting.

Atmosphere

If your planet has an atmosphere using the SgtAtmosphere component, then you can render that on top of the terrain using the SgtTerrainSharedMaterial component. Simply add this component to your terrain GameObject, and drag and drop your atmosphere GameObject into the SgtTerrainSharedMaterial.SharedMaterial setting. The SgtAtmosphere component automatically creates the SgtSharedMaterial component on the same GameObject, which makes sharing the material easy. Other components like SgtCorona also use this shared material system.

Procedural Heights

If you want to procedurally generate planet heights or just augment your heightmap, then you can add the SgtTerrainSimplex component to your terrain GameObject. You can then adjust settings like Amplitude to control the final look.

Surface Colliders

If you want to add colliders to your terrain, then you can add the SgtTerrainCollider component to your terrain GameObject. This component will automatically generate MeshColliders on the surface of your planet based on camera distance. You can control the size of these colliders using the Resolution setting, where a higher value means smaller colliders. You can control the triangle count of these colliders using the Detail setting, and you can control how many colliders spawn around the camera using the Radius setting.

Procedural Prefab Spawning

If you want to add prefabs to your terrain, then you can add the SgtTerrainPrefabSpawner component to your terrain GameObject. This will procedurally spawn prefabs on the surface of your terrain as the camera approaches. These prefabs are spawned in groups whose size is based on your Resolution setting. The amount of spawned groups depends on your Radius setting, and you can control how many can spawn per group with the Limit setting.

Areas

The areas feature allows you to specify where on the terrain your procedural heights and prefabs will appear. To create your own, just duplicate the Features/Terrain/Media/Terrain Areas example asset. This asset allows you to specify a texture, and a list of colors within it you wish to associate with a specific area name.

Once created, you can drag and drop this asset into your SgtTerrainPlanet component's Areas setting. You can now specify which area your procedural height and prefabs spawn.

Optimization

The performance of terrain mesh generation depends on how many triangles are generated, and how fast your camera moves.

The base triangle count is controlled using the SgtTerrainPlanet component's Resolution setting.

When the camera approaches the terrain, its mesh increases in detail. This mesh doubles in detail each time your camera distance halves, and the maximum amount of times it can halve depends on your Radius and Smallest Triangle Size settings.

The amount of triangles generated for each LOD stage is controlled using the Detail setting. A detail setting of 1 is a good starting point for desktop devices. You can use a higher value like 2 for higher performance devices, or a lower value like 0.5 for mobiles and other lower spec devices.

Finally, the performance can also be impacted by camera speed. Each time your camera moves more than one triangle distance, the terrain mesh is updated. If you keep your camera speed the same as it approaches the surface of the terrain, then more and more triangles will have to be generated each frame, which may lower performance. To mitigate this, it is recommend that you slow your camera down as it approaches the surface, so a consistent amount of triangles are generated each frame.

Step 1 - Add a Thruster

Right click in your Hierarchy window, and select Space Graphics Toolkit > Thruster, and you should see a new Thruster GameObject in your scene with the SgtThruster component attached.

If you want the thruster to add force to a Rigidbody then drag and drop your Rigidbody into the Rigidbody inspector setting.

Step 2 - Add a Visual

The most basic visual for a thruster is a sprite. To add one, just add the SpriteRenderer component to your Thruster GameObject, or one of its children.

You can then set the Sprite setting to the Thruster sprite that comes with SGT.

To make it transparent and have an easily adjustable color, change the Material to the Thruster material that comes with SGT. You can now change the color in a way that preserves the white glow in the middle.

Step 3 - Rotate The Visual

Currently your thruster is just a flat sprite that looks bad from different angles, so to make the visual rotate to the camera you can add the SgtThrusterRollcomponent. This will automatically roll it to the currently rendering camera.

Step 4 - Scale The Visual

Currently your thruster remains the same size regardless of the thruster being on or off. To fix this, you can add the SgtThrusterScale component.

This will scale the current GameObject based on the SgtThruster component's Throttle value, and also has options for flickering, and dampening.

Step 5 - Done!

You now have a basic thruster that can add forces to your spaceships.

To control the thrusters based on user input, you need to write a simple script that stores a reference to each SgtThruster you have, and adjust the Throttle value (e.g. 0 to 1) based on these inputs.

What is shifting the scene origin?

Normal Unity scenes store positions using three floats (Vector3), where a position of 0,0,0 is called the origin of the scene. This system works great for most games that take place in a small area, but space games often need to take place over thousands or millions of kilometers, which the Vector3 alone is simply not capable of doing consistently.

The issue is that float values lose decimal precision the higher they get (or lower for negative), which means if your spaceship is 1 million meters/units from the center of the scene, the accuracy of the camera and position values will be very poor, giving you graphical issues, physics issues, and so on. So you want to keep your position values as close to the origin (0,0,0) as possible, so float accuracy remains high.

One solution is instead of moving your camera, you keep your camera fixed at the 0,0,0 origin, and move all the objects in your scene by the distance the camera would have normally moved. This works great, however, it can result in performance issues, because moving objects can sometimes be computationally expensive (e.g. moving physics objects). It can also make scene setup more difficult, and may introduce issues with existing components and scripts that expect the camera to be able to move.

A better solution that SGT uses is instead of keeping the camera at 0,0,0 all the time, it snaps it back to 0,0,0 when it moves too far away. This approach gives good performance because objects only need to have their positions shifted occasionally, it also maintains good rendering precision because values are always near the origin.

Warning!

Before you proceed to use the Universe feature, keep in mind that updating an existing project to include it is difficult, because many things may break without it being clear what the cause is. I highly recommend you only include this in a new project, where you can add things one by one so you immediately know what change caused your scene to break.

Additionally, keep in mind that storing world space positions is not a good idea when the scene origin shifts, because those positions aren't persistent. For example, if you have a missile script that is chasing a specific Vector3 world space position, it will begin chasing the wrong position as soon as the camera snaps. To update these values you can hook into SgtFloatingCamera.OnSnap, you can also instead store relative world-space positions, or use a Transform component.

Finally, if you're making a game with multiple separated cameras (e.g. split screen, security camera), all cameras must be within a reasonable distance of each other at all times, because the Universe feature was designed with one observer in mind, so the origin itself can only move around one main camera at a time. This means you cannot have a split screen game where both players are on opposite sides of the universe, because it makes the scene setup simply too complex to handle.

Basic Setup

At the most basic level, you just need to add the SgtFloatingCamera camera to your camera GameObject (e.g. Main Camera), and the SgtFloatingObject component to all your other GameObjects (e.g. spaceship, planet, character, enemy, asteroid).

Once done, you will see that when your camera moves more than (default) 100 units away from the origin, its position snaps back to the origin, and all objects in your scene will shift by the same amount.

Handling Snaps

If you need to update a script whenever the camera snaps, you can hook into the SgtFloatingCamera.OnSnap event. This event gives you a reference to the SgtFloatingCamera, and gives you a Vector3 containing the world space distance that the scene shifted.

If your script stores world space positions, then you must hook into this event and increment your values by this world space delta the event gives you.

High Precision Positions

You may have noticed that both the SgtFloatingCamera and SgtFloatingObject components store the Local X/Y/Z and Global X/Y/Z values. These values are known as the SgtPosition values, and they allow your objects to be positioned anywhere in the universe with high accuracy.

The local values are equivalent to unity world space units (meters), and the global values are equivalent to 50000000 units (meters) each. Each time a local value exceeds this +- 50000000 value it will reset to 0, and increment the global value.

When combined and used to their limit, these values can precisely store the position of an object +- 461168601842738790400000000 meters across each axis. This is equivalent to +- 48745559677 light years, or 48.7 billion light years, which is greater than the 46.6 billion light year radius of the observable universe.

Spawning Hierarchy

The universe is massive, and it's unrealistic to have all bodies in the universe active at the same time (e.g. galaxies, stars, planets, moons), because your computer would explode. However, you can still create a full universe if you design this in the right way.

The key to this is spawning everything in a hierarchy. For example:

1 - Spawn a few galaxies.

2 - When the camera gets close to a galaxy, spawn some billboard sprites inside that represent massive star clusters.

3 - When the camera gets close to one of these clusters, spawn some smaller clusters inside the massive cluster.

4 - When the camera gets close to one of these smaller clusters, spawn even smaller clusters inside this.

5 - When the camera gets close to this even smaller cluster, you can now spawn some actual 3D stars.

6 - When the camera gets close to one of these stars, spawn some planets around it.

7 - When the camera gets close to one of these planets, spawn some moons, and so on...

If you design this well, then your scene should have no more than a few hundred objects active at the same time, yet still give the illusion of having millions of billions of planets.

All of this can be implemented using the SgtSpawner___ components, which can spawn prefabs in a specific distribution when the camera gets within the Range you specify.

Massive Objects

The basic setup described above works well for 'small' objects (e.g. spaceships, planets, stars) in a massive scene, but they are not capable of rendering truly massive celestial bodies like galaxies. This is due to a limitation of how Unity is implemented, where over a certain size/distance objects just disappear.

However, Space Graphics Toolkit comes with the SgtFloatingMassive component that can solve this issue. This component takes over the current GameObject's Transform settings to size and position massive objects to make them appear as if they are massive and distant, but behind the scenes it's actually small and fairly close.

If your scene needs to be able to render galaxies and other massive distant bodies then you must attach the SgtFloatingMassive component to it, instead of the SgtFloatingObject component.

LayoutType
Layout

The layout of cells in the texture.

int
LayoutColumns

The amount of columns in the texture.

int
LayoutRows

The amount of rows in the texture.

List<Rect>
LayoutRects

The rects of each cell in the texture.

Material
SourceMaterial

The material used to render this component.

Color
Color

This allows you to set the overall color of the atmosphere.

float
Brightness

The Color.rgb values will be multiplied by this.

float
InnerMeshRadius

The radius of the meshes set in the SgtSharedMaterial.

Mesh
OuterMesh

This allows you to set the mesh used to render the atmosphere. This should be a sphere.

float
OuterMeshRadius

This allows you to set the radius of the OuterMesh. If this is incorrectly set then the atmosphere will render incorrectly.

float
OuterSoftness

If you have a big object that is both inside and outside of the atmosphere, it can cause a sharp intersection line. Increasing this setting allows you to change the smoothness of this intersection.

float
Height

This allows you to set how high the atmosphere extends above the surface of the planet in local space.

float
InnerFog

This allows you to adjust the fog level of the atmosphere on the surface.

float
OuterFog

This allows you to adjust the fog level of the atmosphere in the sky.

float
Sky

This allows you to control how quickly the sky reaches maximum opacity as the camera enters the atmosphere.

1 = You must go down to ground level before the opacity reaches max.

2 = You must go at least half way down to the surface.

float
Middle

This allows you to set the altitude where atmospheric density reaches its maximum point. The lower you set this, the foggier the horizon will appear when approaching the surface.

float
CameraOffset

This allows you to offset the camera distance in world space when rendering the atmosphere, giving you fine control over the render order.

float
OcclusionPower

This setting allows you to increase or decrease how much this atmosphere occludes flares using the SgtOcclusionScaler component.

bool
Night

Should the night side of the atmosphere have different sky values?

float
NightSky

The 'Sky' value of the night side.

SgtEase.Type
NightEase

The transition style between the day and night.

float
NightStart

The start point of the day/sunset transition (0 = dark side, 1 = light side).

float
NightEnd

The end point of the day/sunset transition (0 = dark side, 1 = light side).

float
NightPower

The power of the night transition.

Color
HorizonColor

This allows you to set the color that appears on the horizon.

Color
InnerColor

The base color of the inner texture.

SgtEase.Type
InnerEase

The transition style between the surface and horizon.

float
InnerColorSharpness

The strength of the inner texture transition.

float
InnerAlphaSharpness

The strength of the inner texture transition.

Color
OuterColor

The base color of the outer texture.

SgtEase.Type
OuterEase

The transition style between the sky and horizon.

float
OuterColorSharpness

The strength of the outer texture transition.

float
OuterAlphaSharpness

The strength of the outer texture transition.

void
ExportInnerTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtAtmosphere component's InnerDepth setting using the exported asset.

void
ExportOuterTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtAtmosphere component's OuterDepth setting using the exported asset.

float
DistanceMin

The minimum distance between the atmosphere center and the camera position in local space.

float
DistanceMax

The maximum distance between the atmosphere center and the camera position in local space.

float
HeightClose

The SgtAtmosphere.Height value that will be set when at or below DistanceMin.

float
HeightFar

The SgtAtmosphere.Height value that will be set when at or above DistanceMax.

SgtEase.Type
SunsetEase

The transition style between the day and night.

float
SunsetStart

The start point of the day/sunset transition (0 = dark side, 1 = light side).

float
SunsetEnd

The end point of the sunset/night transition (0 = dark side, 1 = light side).

float
SunsetSharpnessR

The sharpness of the sunset red channel transition.

float
SunsetSharpnessG

The sharpness of the sunset green channel transition.

float
SunsetSharpnessB

The sharpness of the sunset blue channel transition.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtAtmosphere component's LightingTex setting using the exported asset.

SgtEase.Type
SunsetEase

The transition style between the day and night.

float
SunsetStart

The start point of the day/sunset transition (0 = dark side, 1 = light side).

float
SunsetEnd

The end point of the sunset/night transition (0 = dark side, 1 = light side).

float
SunsetSharpnessR

The sharpness of the sunset red channel transition.

float
SunsetSharpnessG

The sharpness of the sunset green channel transition.

float
SunsetSharpnessB

The sharpness of the sunset blue channel transition.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtAtmosphere component's ScatteringTex setting using the exported asset.

Material
SourceMaterial

The material used to render this component.

Color
Color

This allows you to set the overall color of the aurora.

float
Brightness

The Color.rgb values will be multiplied by this.

float
CameraOffset

This allows you to offset the camera distance in world space when rendering the aurora, giving you fine control over the render order.

int
Seed

This allows you to set the random seed used during procedural generation.

float
RadiusMin

The inner radius of the aurora mesh in local space.

float
RadiusMax

The inner radius of the aurora mesh in local space.

int
PathCount

The amount of aurora paths/ribbons.

int
PathDetail

The amount of quads used to build each path.

float
PathLengthMin

The minimum length of each aurora path.

float
PathLengthMax

The maximum length of each aurora path.

float
StartMin

The minimum distance between the pole and the aurora path start point.

float
StartMax

The maximum distance between the pole and the aurora path start point.

float
StartBias

The probability that the aurora path will begin closer to the pole.

float
StartTop

The probability that the aurora path will start on the northern pole.

int
PointDetail

The amount of waypoints the aurora path will follow based on its length.

float
PointSpiral

The strength of the aurora waypoint twisting.

float
PointJitter

The strength of the aurora waypoint random displacement.

float
TrailEdgeFade

The sharpness of the fading at the start and ends of the aurora paths.

float
TrailTile

The amount of times the main texture is tiled based on its length.

float
TrailHeights

The flatness of the aurora path.

int
TrailHeightsDetail

The amount of height changes in the aurora path.

Gradient
Colors

The possible colors given to the top half of the aurora path.

int
ColorsDetail

The amount of color changes an aurora path can have based on its length.

float
ColorsAlpha

The minimum opacity multiplier of the aurora path colors.

float
ColorsAlphaBias

The amount of alpha changes in the aurora path.

float
AnimStrength

The strength of the aurora path position changes in local space.

int
AnimStrengthDetail

The amount of the animation strength changes along the aurora path based on its length.

float
AnimAngle

The maximum angle step between sections of the aurora path.

int
AnimAngleDetail

The amount of the animation angle changes along the aurora path based on its length.

float
NoiseStrength

The strength of the noise points.

int
NoisePoints

The amount of noise points.

int
NoiseSeed

The random seed used when generating this texture.

SgtEase.Type
TopEase

The transition style between the top and middle.

float
TopSharpness

The transition strength between the top and middle.

float
MiddlePoint

The point separating the top from bottom.

Color
MiddleColor

The base color of the aurora starting from the bottom.

SgtEase.Type
MiddleEase

The transition style between the bottom and top of the aurora.

float
MiddleSharpness

The strength of the color transition between the bottom and top.

SgtEase.Type
BottomEase

The transition style between the bottom and middle.

float
BottomSharpness

The transition strength between the bottom and middle.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtAurora component's MainTex setting using the exported asset.

SgtEase.Type
Ease

The ease type used for the transition.

float
Sharpness

The sharpness of the transition.

float
Offset

The start point of the fading.

float
OverrideRange

Should this component also control the aurora's NearRangeRecip setting?

-1 = Don't override.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtAurora component's NearTex setting using the exported asset.

Material
SourceMaterial

The material used to render this component.

Color
Color

This allows you to set the overall color of the backdrop.

float
Brightness

The Color.rgb values will be multiplied by this.

Texture
MainTex

This allows you to set the texture applied to the starfield. If this texture can contains multiple stars then you can specify their location using the Atlas setting.

SgtAtlas
Atlas

If the main texture of this material contains multiple textures in an atlas, then you can specify them here.

float
ClampSizeMin

Should the stars fade out instead of shrink when they reach a certain minimum size on screen?

int
Seed

This allows you to set the random seed used during procedural generation.

float
Radius

The radius of the starfield.

float
Squash

Should more stars be placed near the horizon?

int
StarCount

The amount of stars that will be generated in the starfield.

Gradient
StarColors

Each star is given a random color from this gradient.

float
StarRadiusMin

The minimum radius of stars in the starfield.

float
StarRadiusMax

The maximum radius of stars in the starfield.

float
StarRadiusBias

How likely the size picking will pick smaller stars over larger ones (1 = default/linear).

float
StarPulseSpeedMin

The minimum animation speed of the pulsing.

float
StarPulseSpeedMax

The maximum animation speed of the pulsing.

static SgtBackdropQuad
Temp

Temp instance used when generating the starfield

int
Variant

The coordinate index in the atlas texture.

Color
Color

Color tint of this quad.

float
Radius

Radius of this quad in local space.

float
Angle

Angle of this quad in degrees.

Vector3
Position

Position of the quad in local space.

float
PulseSpeed

How fast this star pulses.

float
PulseOffset

The pulse position will be offset by this value so they don't all pulse the same.

int
Seed

This allows you to set the random seed used during procedural generation.

float
Radius

The radius of the background mesh.

float
Squash

Should more quads be placed near the horizon?

int
QuadCount

The amount of quads that will be generated in the background.

float
QuadRadiusMin

The minimum radius of quads in the background.

float
QuadRadiusMax

The maximum radius of quads in the background.

float
QuadRadiusBias

How likely the size picking will pick smaller quads over larger ones (1 = default/linear).

Material
SourceMaterial

The material used to render this component.

Color
Color

This allows you to set the overall color of the belt.

float
Brightness

The Color.rgb values will be multiplied by this.

Texture
MainTex

This allows you to set the texture applied to the belt. If this texture can contains multiple asteroids then you can specify their location using the Atlas setting.

SgtAtlas
Atlas

If the main texture of this material contains multiple textures in an atlas, then you can specify them here.

float
OrbitOffset

The amount of seconds this belt has been animating for.

float
OrbitSpeed

The animation speed of this belt.

static SgtBeltAsteroid
Temp

Temp instance used when generating the belt.

int
Variant

The coordinate index in the asteroid texture.

Color
Color

Color tint of this asteroid.

float
Radius

Radius of this asteroid in local space.

float
Height

Height of this asteroid's orbit in local space.

float
Angle

The base roll angle of this asteroid in radians.

float
Spin

How fast this asteroid rolls in radians per second.

float
OrbitAngle

The base angle of this asteroid's orbit in radians.

float
OrbitSpeed

The speed of this asteroid's orbit in radians.

float
OrbitDistance

The distance of this asteroid's orbit in radians.

float
Occlusion

This allows you to specify how much light the asteroids can block when using light flares.

float
OuterRadius

This allows you to specify the outer radius of the belt when calculating lighting.

List<SgtBeltAsteroid>
Asteroids

The custom asteroids in this belt.

float
FrontPower

How sharp the incoming light scatters forward.

float
BackPower

How sharp the incoming light scatters backward.

float
BackStrength

The strength of the back scattered light.

float
BaseStrength

The of the perpendicular scattered light.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtBelt component's LightingTex setting using the exported asset.

int
Seed

This allows you to set the random seed used during procedural generation.

float
Thickness

The thickness of the belt in local coordinates.

float
ThicknessBias

The higher this value, the less large asteroids will be generated.

float
InnerRadius

The radius of the inner edge of the belt in local coordinates.

float
InnerSpeed

The speed of asteroids orbiting on the inner edge of the belt in radians.

float
OuterRadius

The radius of the outer edge of the belt in local coordinates.

float
OuterSpeed

The speed of asteroids orbiting on the outer edge of the belt in radians.

float
RadiusBias

The higher this value, the more likely asteroids will spawn on the inner edge of the ring.

float
SpeedSpread

How much random speed can be added to each asteroid.

int
AsteroidCount

The amount of asteroids generated in the belt.

Gradient
AsteroidColors

Each asteroid is given a random color from this gradient.

float
AsteroidSpin

The maximum amount of angular velocity each asteroid has.

float
AsteroidRadiusMin

The minimum asteroid radius in local coordinates.

float
AsteroidRadiusMax

The maximum asteroid radius in local coordinates.

float
AsteroidRadiusBias

How likely the size picking will pick smaller asteroids over larger ones (1 = default/linear).

bool
RollWithCamera

If the camera rolls, should this billboard roll with it?

bool
AvoidClipping

If your billboard is clipping out of view at extreme angles, then enable this.

Material
SourceMaterial

The material used to render this component.

Mesh
Mesh

The mesh applied used to render the black hole. This should be a sphere.

float
Pinch

The higher you set this, the smaller the spatial distortion will be.

float
Warp

The higher you set this, the more space will bend around the black hole.

float
HoleSize

This allows you to control the overall size of the hole relative to the pinch.

float
HoleSharpness

This allows you to control how sharp/abrupt the transition between space and the event horizon is.

Color
HoleColor

This allows you to control the color of the black hole past the event horizon.

Color
TintColor

The color of the tint.

float
TintSharpness

This allows you to control how sharp/abrupt the transition between the event horizon and the tinted space is.

float
FadePower

This allows you to fade the edges of the black hole. This is useful if you have multiple black holes near each other.

float
RollAngle

The amount of degrees this camera has rolled (used to counteract billboard non-rotation).

Quaternion
RollQuaternion

A quaternion of the current roll angle.

Matrix4x4
RollMatrix

A matrix of the current roll angle.

static LinkedList<SgtCamera>
Instances

This stores all active and enabled instances of this component.

bool
Listen

Is this component currently listening for inputs?

float
Damping

How quickly the position goes to the target value (-1 = instant).

Rigidbody
Target

If you want movements to apply to Rigidbody.velocity, set it here.

RotationType
TargetRotation

If the target is something like a spaceship, rotate it based on movement?

float
TargetDamping

The speed of the velocity rotation.

float
SpeedMin

The movement speed will be multiplied by this when near to planets.

float
SpeedMax

The movement speed will be multiplied by this when far from planets.

float
SpeedRange

The higher you set this, the faster the SpeedMin value will be reached when approaching planets.

float
SpeedWheel

CwInputManager.Axis
HorizontalControls

The keys/fingers required to move left/right.

CwInputManager.Axis
DepthControls

The keys/fingers required to move backward/forward.

CwInputManager.Axis
VerticalControls

The keys/fingers required to move down/up.

Camera
Camera

The camera associated with this state.

Material
SourceMaterial

The material used to render this component.

Color
Color

This allows you to set the overall color of the cloudsphere.

float
Brightness

The Color.rgb values will be multiplied by this.

Cubemap
MainTex

This allows you to set the cubemap texture applied to the cloudsphere.

float
Radius

This allows you to set the radius of the cloudsphere in local space.

float
CameraOffset

This allows you to offset the camera distance in world space when rendering the cloudsphere, giving you fine control over the render order.

float
Softness

Should the stars fade out if they're intersecting solid geometry?

Mesh
Mesh

This allows you to set the mesh used to render the cloudsphere. This should be a sphere.

float
MeshRadius

This allows you to set the radius of the Mesh. If this is incorrectly set then the cloudsphere will render incorrectly.

SgtEase.Type
RimEase

The rim transition style.

Color
RimColor

The rim color.

float
RimPower

The rim transition sharpness.

float
AlphaDensity

The density of the atmosphere.

float
AlphaFade

The strength of the density fading in the upper atmosphere.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtCloudsphere component's DepthTex setting using the exported asset.

SgtEase.Type
SunsetEase

The transition style between the day and night.

float
SunsetStart

The start point of the sunset (0 = dark side, 1 = light side).

float
SunsetEnd

The end point of the sunset (0 = dark side, 1 = light side).

float
SunsetSharpnessR

The sharpness of the sunset red channel transition.

float
SunsetSharpnessG

The sharpness of the sunset green channel transition.

float
SunsetSharpnessB

The sharpness of the sunset blue channel transition.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtCloudsphere component's LightingTex setting using the exported asset.

SgtEase.Type
Ease

The ease type used for the transition.

float
Sharpness

The sharpness of the transition.

float
Offset

The start point of the fading.

float
OverrideRange

Should this component also control the starfield's NearRangeRecip setting?

-1 = Don't override.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtCloudsphere component's NearTex setting using the exported asset.

static event OcclusionDelegate
OnCalculateOcclusion

This event allows you to register a custom occlusion calculation.

static int
GetOffset
TextureFormat format, int channel

Gets the byte offset of a texture channel based on its format.

Channel = 0 = Red.

Channel = 1 = Green.

Channel = 2 = Blue.

Channel = 3 = Alpha.

event System.Action
OnSpawn

Called when this debris is spawned (if pooling is enabled).

event System.Action
OnDespawn

Called when this debris is despawned (if pooling is enabled).

bool
Pool

Can this debris be pooled?

StateType
State

The current state of the scaling.

SgtDebris
Prefab

The prefab this was instantiated from.

Vector3
Scale

This gets automatically copied when spawning debris.

SgtLong3
Cell

The cell this debris was spawned in.

Transform
Target

The transform the debris will spawn around.

None/null = Main Camera.

SgtShapeGroup
SpawnInside

The shapes the debris will spawn inside.

float
ShowDistance

The distance from the target that debris begins spawning.

float
HideDistance

The distance from the target that debris gets hidden.

int
CellCount

This allows you to set how many cells are in the grid on each axis within the Hide Distance.

float
CellNoise

How far from the center of each cell the debris can be spawned. This should be decreased to stop debris intersecting.

float
DebrisCountTarget

The maximum expected amount of debris based on the cell size settings.

float
ScaleMin

The minimum scale multiplier of the debris.

float
ScaleMax

The maximum scale multiplier of the debris.

float
ScaleBias

If this is above 0 then small debris are more likely to spawn. If this value is below 0 then big debris are more likely to spawn.

bool
RandomRotation

Should the debris be given a random rotation, or inherit from the prefab that spawned it?

int
Seed

This allows you to set the random seed used during procedural generation.

List<SgtDebris>
Prefabs

These prefabs are randomly picked from when spawning new debris.

Transform
Target

If this transform is inside the radius then debris will begin spawning.

SgtShapeGroup
SpawnInside

The shapes the debris will spawn inside.

float
ShowSpeed

How quickly the debris shows after it spawns.

float
ShowDistance

The distance from the follower that debris begins spawning.

float
HideDistance

The distance from the follower that debris gets hidden.

bool
SpawnOnAwake

Should all the debris be automatically spawned at the start?

int
SpawnLimit

The maximum amount of debris that can be spawned.

float
SpawnRateMin

The minimum amount of seconds between debris spawns.

float
SpawnRateMax

The maximum amount of seconds between debris spawns.

float
SpawnScaleMin

The minimum scale multiplier applied to spawned debris.

float
SpawnScaleMax

The maximum scale multiplier applied to spawned debris.

List<SgtDebris>
Prefabs

These prefabs are randomly picked from when spawning new debris.

bool
ForceScatteringHdrInHDRP

If you enable this setting and your project is running with HDRP and your scene contains SgtAtmosphere components with scattering, then their ScatteringHdr settings will be enabled.

KeyCode
Key

The key that must be held for this component to activate on desktop platforms.

None = Any mouse button.

LayerMask
GuiLayers

Fingers that began touching the screen on top of these UI layers will be ignored.

float
Pitch

The target pitch angle in degrees.

float
PitchSensitivity

The speed the pitch changed relative to the mouse/finger drag distance.

float
PitchMin

The minimum value of the pitch value.

float
PitchMax

The maximum value of the pitch value.

float
Yaw

The target yaw angle in degrees.

float
YawSensitivity

The speed the yaw changed relative to the mouse/finger drag distance.

bool
YawClamp

Clamp the yaw value?

float
YawMin

The minimum value of the pitch value.

float
YawMax

The maximum value of the pitch value.

float
Damping

How quickly the rotation transitions from the current to the target value (-1 = instant).

float
Drag

The attached Rigidbody will be given this drag by default.

LayerMask
Layers

The allows you to choose which SgtDragSource layers are used.

float
Drag

The drag applied to the drag receivers.

SgtShape
Shape

This allows you to specify the shape of this drag volume.

bool
RollWithCamera

If the camera rolls, should this billboard roll with it?

bool
AvoidClipping

If your billboard is clipping out of view at extreme angles, then enable this.

static LinkedList<SgtFastBillboard>
Instances

This stores all active and enabled instances of this component.

static LinkedList<SgtFastBillboardManager>
Instances

This stores all active and enabled instances of this component.

Material
SourceMaterial

The material used to render this component.

Mesh
Mesh

This allows you to set the mesh used to render the flare.

bool
FollowCameras

Should the flare automatically snap to cameras.

float
FollowDistance

The distance from the camera this flare will be placed in world space.

float
CameraOffset

This allows you to offset the camera distance in world space when rendering the flare, giving you fine control over the render order.

Color
Color

The base color will be multiplied by this.

SgtEase.Type
Ease

The color transition style.

float
SharpnessR

The sharpness of the red transition.

float
SharpnessG

The sharpness of the green transition.

float
SharpnessB

The sharpness of the blue transition.

void
ExportTexture

This method allows you to export the generated texture as an asset.

Once done, you can remove this component, and set the SgtFlare component's Material setting using the exported asset.

int
Detail

The amount of points used to make the flare mesh.

float
Radius

The base radius of the flare in local space.

bool
Wave

Deform the flare based on cosine wave?

float
WaveStrength

The strength of the wave in local space.

int
WavePoints

The amount of wave peaks.

float
WavePower

The sharpness of the waves.

float
WavePhase

The angle offset of the waves.

bool
Noise

Deform the flare based on noise?

float
NoiseStrength

The strength of the noise in local space.

int
NoisePoints

The amount of noise points.

float
NoisePhase

The angle offset of the noise.

int
NoiseSeed

The random seed used for the random noise.

void
ExportMesh

This method allows you to export the generated mesh as an asset.

Once done, you can remove this component, and set the SgtFlare component's Mesh setting using the exported asset.

float
BrightnessNear

The brightness value when at or below the DistanceMin.

float
BrightnessFar

The brightness value when at or above the DistanceMax.

SgtLength
DistanceMin

The distance where the BrightnessNear will be used.

SgtLength
DistanceMax

The distance where the BrightnessFar will be used.

FloatEvent
OnBrightness

The calculated brightness value will be output via this event.

double
MassiveDistance

The maximum camera distance objects can render at when using the SgtFloatingMassive component.

float
SnapDistance

When the transform.position.magnitude exceeds this value, the position will be snapped back to the origin.

SgtPosition
SnappedPoint

Every time this camera's position gets snapped, its position at that time is stored here. This allows other objects to correctly position themselves relative to this.

static event System.Action<SgtFloatingCamera, Vector3>
OnSnap

Called when this camera's position snaps back to the origin (Vector3 = delta).

static bool
TryGetInstance
ref SgtFloatingCamera instance

This method will fill the instance with the first active and enabled SgtFloatingCamera instance in the scene and return true, or return false.

SgtPosition
GetPosition
Vector3 worldPosition

This method converts the specified world space position into a universal SgtPosition.

Vector3
CalculatePosition
SgtPosition input

This method converts the specified universal SgtPosition into a world space position.

Vector3
CalculatePosition
ref SgtPosition input

This method converts the specified universal SgtPosition into a world space position.

void
TrySnap

If the current Transform.position has strayed too far from the origin, this method will then call Snap.

void
Snap

This method will reset the current Transform to 0,0,0 then update all SgtFloatingObjects in the scene.

SgtFloatingPoint
Target

This allows you to specify the SgtFloatingPoint this component will follow.

float
Damping

How quickly this point follows the target.

-1 = instant.

bool
Rotate

Should this transform's rotation also match that of the target?

Vector3
LocalPosition

This allows you to specify a positional offset relative to the Target.

Vector3
LocalRotation

This allows you to specify a rotational offset relative to the Target.

static LinkedList<SgtFloatingLight>
Instances

This stores all active and enabled instances of this component.

GameObject
Prefab

The prefab that will be spawned.

SgtLength
DistanceMin

If the camera is closer than this distance, then the LOD will disappear.

SgtLength
DistanceMax

If the camera is farther than this distance, then the LOD will disappear.

bool
Spawned

This will be set while the LOD is within range.

GameObject
Clone

This allows you to get the spawned prefab clone.

Vector3
Scale

This setting allows you to adjust the per-axis size of this object.

SgtLength
Size

The base scale of this object.

int
Seed

This allows you to set the random seed used during procedural generation. If this object is spawned from an SgtFloatingSpawner___ component, then this will automatically be set.

event System.Action<int>
OnSpawn

If this object is spawned from an SgtFloatingSpawner___ component, then it will be given a seed and this event will be invoked.

int = Seed.

event System.Action<double>
OnDistance

This event is called every Update with the current distance to the camera.

void
ResetPosition

This method allows you to reset the Position, which will then be calculated in Start, or when you manually call the DerivePosition method.

You should use this if your object is part of a prefab, and you want to spawn it using Transform.position values.

void
DerivePosition

This method will calculate the Position based on the current Transform.position value relative to the current SgtFloatingCamera.

void
InvokeOnSpawn

You can call this method to invoke the OnSpawn method.

SgtLength
Radius

The radius of the orbit in meters.

float
Oblateness

How squashed the orbit is.

Vector3
Tilt

The local rotation of the orbit in degrees.

Vector3
Offset

The local offset of the orbit in meters.

double
Angle

The current position along the orbit in degrees.

double
DegreesPerSecond

The orbit speed.

SgtFloatingPoint
ParentPoint

The center orbit point. NOTE: This should be null/None if it will be spawned by SgtFloatingSpawnerOrbit.

SgtFloatingOrbit
Orbit

The orbit that will be rendered by this component.

Material
Material

The material of the orbit.

SgtLength
Thickness

The thickness of the visual ring in local space.

int
Points

The amount of points used to draw the orbit.

Gradient
Colors

The color of the orbit ring as it goes around the orbit.

SgtPosition
Position

The position wrapped by this component.

event System.Action
OnPositionChanged

Whenever the Position values are modified, this gets called. This is useful for components that depend on this position being known at all times (e.g. SgtFloatingOrbit).

void
NotifyPositionChanged

This method will invoke the OnPositionChanged event.

void
ApplyPosition

This method will apply the current Position to the Transform.Position, in case they go out of sync.

void
SetPosition
SgtPosition newPosition

This method allows you to change the whole Position state, and it will automatically call the PositionChanged method if the position is different.

static LinkedList<SgtFloatingRoot>
Instances

This stores all active and enabled instances of this component.

Transform
Target

If you want a different Transform to be scaled, you can specify it here.

Vector3
Scale

The base scale of the object.

double
Multiplier

The final scale will be multiplied by this.

SgtLength
Range

If the distance between the camera and this object is beyond this value, this object will be scaled to 0 and be invisible.

SgtFloatingObject
CachedObject

The SgtFloatingObject component alongside this component.

SgtLength
Range

The camera must be within this range for this spawner to activate.

string
Category

If you want to define prefabs externally, then you can use the SgtSpawnList component with a matching Category name.

List<SgtFloatingObject>
Prefabs

If you aren't using a spawn list category, or just want to augment the spawn list, then define the prefabs you want to spawn here.

bool
RandomizeIndex

If you disable this then the spawned object will use the same prefab as the spawn index.

SgtFloatingObject
CachedObject

The SgtFloatingObject component alongside this component.

int
Count

The amount of prefabs that will be spawned.

float
TiltMax

The maximum degrees an orbit can tilt.

float
OblatenessMax

The maximum amount an orbit can be squashed.

SgtLength
RadiusMin

The minimum distance away the prefabs can spawn.

SgtLength
RadiusMax

The maximum distance away the prefabs can spawn in meters.

int
Count

The amount of prefabs that will be spawned.

SgtLength
RadiusMin

The minimum distance away the prefabs can spawn.

SgtLength
RadiusMax

The maximum distance away the prefabs can spawn in meters.