Space Graphics Toolkit


DOCUMENTATION

Thank you for using Space Graphics Toolkit ❤️

If you haven't already, please consider writing a review. They really help me out!

Space Graphics Toolkit (SGT) is a large collection of components, shaders, and graphical effects that can be combined in any way you like to make impressive space scenes.

This asset is split into Feature and Pack folders.


Features

Feature folders contain mostly code and example scenes for a specific SGT feature. For example, the Accretion folder contains components and shaders allowing you to add animated accretion discs to your scene.



Packs

Pack folders contain mostly media and example scenes for a group of SGT features. For example, the Alien Worlds Pack contains a selection of alien planet textures, materials, and demo scenes.

NOTE  If you've purchased the Planet Pack, then you can read its READ ME in the Space Graphics Toolkit/Packs/Planet Pack folder.



Required Packages

NOTE  Space Graphics Toolkit requires the Burst package to be manually installed if you want to use the Terrain feature.

To install this package, first open the Package Manager window, and wait for the package list to finish downloading.

Click the dropdown, and select Unity Registry, so you can see all of Unity's official packages.

Once the list loads, scroll down to find the Burst package, and click Install.

You should now be able to enjoy the full Space Graphics Toolkit experience!



How do I upgrade?

First, make sure you back up your project files.

Next, install the latest version.

If for some reason the latest updates breaks your project (e.g. errors in the console), then try deleting the root folder for this asset, and reinstalling it.

If it still doesn't work then go back to your previous version, and let me know what the errors are, so I can fix it.



Where do I get more packs?

To reduce file size, I only include a few examples in the main asset. This allows me to release updates more efficiently. To get more, click the links below.


[FREE] Alien Worlds Pack

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

You can download it from HERE.

NOTE  This pack requires the full Space Graphics Toolkit asset to function.


[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.

NOTE  This pack requires the full Space Graphics Toolkit asset to function.


[FREE] Star Pack

This pack contains a variety of stars, nebulae, and galaxies.

You can download it from HERE.

NOTE  This pack requires the full Space Graphics Toolkit asset to function.


[PAID] Planet Pack

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.

NOTE  This is a standalone asset, so it does NOT require SGT.



Why does each feature require so many components?

Many SGT features are rendered using a combination of components. For example, the Accretion feature (animated accretion disc) is rendered using the SgtAccretion, SgtAccretionMesh, and SgtAccretionNearTex components.

The main reason why these components are separate is to improve code organization, but this system also allows you to optimize your scene. If you click the context menu button (gear icon) at the top right of these components, you'll notice you have the option to Export Mesh, Export Texture, or similar. For example, the SgtAccretionMesh component's context menu has the Export Mesh option. This allows you to save the generated accretion disc mesh as an asset, so you can now remove this component, and drag and drop your saved mesh into the SgtAccretion component's Mesh setting.

Doing this allows you to improve performance of your scene, because the SgtAccretionMesh component no longer has to generate a new mesh each time you add an accretion disc to your scene. The downside of course is that you can no longer adjust the mesh settings, so it may not be suitable for your project if you need to be able to control the generation settings in game.

For more information about which components can export what meshes/textures/etc, look at the documentation specific to the feature you're interested in.



How do I use this from C#?

Most features of SGT work the same in the editor as they do from C# code, including the identifiers for each setting. For example, to add an atmosphere to a planet just add the SgtAtmosphere component, as you would do in the editor, and the settings you modify from code should be the same as from the editor.

Therefore, to understand how to set something up from code, I recommend you first try to do it in the editor. Each feature of SGT has its own folder with demo scenes that take you through most of the main features, and each component setting has tooltip information to help you.

The biggest difference is that the in-editor experience has some presets that can save you time. For example, components like SgtAtmosphere require you to set the sphere mesh used to render the outer atmosphere. In the editor this can automatically be set, but from code you would have to manually load it yourself.



Which versions of Unity are supported?

Space Graphics Toolkit is currently developed using Unity 2019.4, because this is the minimum version required for new Asset Store submissions.

All features have been tested up to Unity 2020.2 and are known to work.

If you're using an earlier version of Unity (e.g. 2018), then most/all features should still work, but I no longer test with these old versions so I can't guarantee it.



Is URP/HDRP supported?

Space Graphics Toolkit supports all 3 render pipelines (Standard, URP, HDRP) in a seamless way that automatically detects your current project settings, and makes the required modifications.


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 SGT) currently supports:

Standard - All versions supported by SGT.

URP - Unity 2019 LTS

URP - Unity 2020.2 to 2020.3

HDRP - Unity 2019 LTS

HDRP - Unity 2020.2 to 2020.3

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



Lights

Each rendering pipeline handles lighting differently. To make the scenes look consistent, each light has the SgtLight component attached to it, which overrides the light intensity for each pipeline.

If you don't like this behavior then you can set the values (for example IntensityInHDRP) to -1.



Opaque Texture (URP only)

If you want to use the SgtBlackHole feature, then you must enable the Opaque Texture setting in your pipeline settings asset.



Volume (HDRP only)

To make HDRP compatibility seamless, each demo scene contains the SgtSceneManager GameObject, which 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 delete this GameObject, and create your own volume.

However, for your own scenes you may want to remove this volume component and use your own exposure settings.




Is VR supported?

Yes, this asset has been developed and tested in VR, and supports both multi-pass & single-pass rendering modes.

NOTE  Some features of SGT will need modification to look good in VR. For example, many of the demo scenes uses static star backgrounds (e.g. SgtBackdrop), which you can replace with fully 3D ones with the SgtStarfieldElliptical component.

You can see the VR Stars demo scene for an example of how starfields can be set up to create an immersive scene.



Does this work on mobile/console/WebGL/etc?

Yes, all features of this asset have been written with maximum compatibility and in mind, and have been heavily optimized to run on almost any device and platform, while still giving impressive visual results.



Known Issues


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!



Terrain Ocean in HDRP

The Ocean part of the Terrain feature currently doesn't render properly in HDRP due to depth texture issues. This will be fixed soon.



Lighting in HDRP

Features that implement their own lighting (e.g. SgtAccretion, SgtJovian, SgtAtmosphere) don't correctly work with HDRP post processing features like exposure. This is because HDRP requires special unlit shaders. In a future version these shaders will be rewritten to support HDRP lighting properly.




Accretion

The Accretion feature allows you to create accretion discs. An accretion disc is a swirling vortex of matter falling toward a massive body like a star, or black hole.


Making an Accretion Disc

Begin by right clicking in your Hierarchy tab, and selecting: Space Graphics Toolkit > Accretion

Or from the menu bar: GameObject > Space Graphics Toolkit > Accretion

Your scene should now contain a new selected GameObject called Accretion, with the SgtAccretion component attached.

If you click the Add Mesh button, the SgtAccretionMesh component will be added, and this will automatically generate the SgtAccretion.Mesh setting for you.

Next, you need to set the SgtAccretion.MainTex setting. The accretion example media comes with the Accretion_Main texture, which you can use here. This should be a vertically seamless texture, where the left edge is the inner edge of the disc.

You now have a very basic accretion disc.

NOTE  The accretion disc is split into multiple segments (default = 8). This allows it to correctly depth sort against objects you want to place in the center (e.g. a planet). If it were a single GameObject then it wouldn't work in such a scenario, you can test this by setting the SgtAccretion.Segments and SgtAccretionMesh.Segments setting to 1, and you will see it renders incorrectly in some scenarios with an object placed in the center.


Adding Detail

If you want matter to fall into the accretion disc, you need to enable the SgtAccretion.Detail setting. You can now set the SgtAccretion.DetailTex setting. The Accretion_Detail texture that comes with SGT can be used here.

NOTE  This should be a seamless texture that tiles on both the X and Y axis.

To make it fall into the disc you need to set the SgtAccretion.DetailSpeed setting (e.g. 1,1).

To make the matter fall in non-linearly, you can adjust the SgtAccretion.DetailTwist setting (e.g. 2).

To make the matter slow its rotation as it approaches the inner edge, you can adjust the SgtAccretion.DetailTwistBias setting (e.g. 1.5).



My Disc Segments Clip Through Objects in the Center?

While the segment splitting improves depth sorting against objects in the center, it won't always fix it 100%.

To improve this you can try increasing the SgtAccretionMesh.BoundsShift setting, or increasing the Segments setting in both components.




Atmosphere

The Atmosphere feature allows you to add a volumetric atmosphere above a planet's surface.


Adding an Atmosphere

An atmosphere can be added on top of a normal sphere to give it a nice volumetric haze.

Begin by right clicking in your Hierarchy tab and selecting: Space Graphics Toolkit > Atmosphere

Or from the menu bar: GameObject > Space Graphics Toolkit > Atmosphere

NOTE  If you want to add this on top of an existing sphere/planet, then right click your object, or select it before using the menu.

Your scene should now contain a new selected GameObject called Atmosphere with the SgtAtmosphere component.

You should now see a lot of settings marked in red, and three buttons at the bottom. If you click these three buttons then the atmosphere will be set up with default settings, and you should see it in the scene. If you don't see anything, you may need to adjust the SgtAtmosphere.Heightsetting, or add your planet renderers to the SgtSharedMaterial.Renderers list.



Adding Lighting

Atmospheres aren't lit by default, to enable this tick the SgtAtmosphere.Lit setting. You can then click the Add LightingTex button to add the SgtAtmosphereLightingTex component.

If your atmosphere turned completely black, then you probably don't have any SGT lights in your scene. To add one, select your light GameObject (e.g. point light), and add the SgtLight component.

Your atmosphere should now automatically detect this and receive lighting.



Adding Atmospheric Scattering

Tick the SgtAtmosphere.Scattering setting, and click the Add ScatteringTex button. Your atmosphere should now have atmospheric scattering.

To see the atmospheric scattering, move your camera into the atmosphere, and look toward your light source.

You can now adjust its settings like SgtAtmosphere.ScatteringMie, which adjust the light halo size/sharpness.

You can also adjust the SgtAtmosphere.ScatteringRayleigh setting, which adjusts the front and back light scattering brightness.

If you want to adjust the color of the scattering, especially near sunrise/sunset, then you can adjust them in the SgtAtmosphereScatteringTex component. The SgtAtmosphereScatteringTex.SunsetSharpnessR/G/B settings controls that color change. You can also control when the

color transition begins and ends using the SgtAtmosphereScatteringTex.SunsetStart/End sliders.



Atmosphere Thickness

In real life, planet atmospheres are very thin relative to the size of the planet. To make the scenes look more interesting in SGT I made the planet atmospheres much thicker. However, if you make them too thin then the atmosphere may not look so impressive up close, because your planets probably aren't going to be so big. If you want the best of both worlds then you can use the SgtAtmosphereHeight component.

This component will adjust the SgtAtmosphere.Height setting based on the distance between the camera and your planet, allowing you to have thin and realistic atmospheres from a distance, and thicker more interesting looking ones up close.



Lighting Tex

The SgtAtmosphereLightingTex component allows you to control the color of the atmosphere based on the angle of the light, and control the sunset/sunrise colors. Keep in mind that the SunsetStart/End values should be chosen with consideration to the size of your atmosphere. If your atmosphere is very thick, then it's likely the sunset point will be pushed back quite far, and be spread over a large range. Whereas if your atmosphere is thin, then the sunset period is likely to be quite short.



Scattering Tex

The SgtAtmosphereScatteringTex component allows you to specify how far into sunset the light scattering appears, and its colors. Keep in mind that setting the SunsetStart too early means you will see sunlight scattering through your planet, so make sure you test it in your game so it looks good and fades out at the right time.



Other Objects/Renderers

By default, the SgtAtmosphere component only applies atmospheric fog to the planet surface. If you have objects on the surface of your planet then they will not receive any fog. This usually isn't an issue for planet objects that are near the camera (e.g. player spaceship), but if you need to place an object on your planet and move far away, then you probably want fog to be applied to it. To do this, simply drag and drop the MeshRenderer you want into the SgtSharedMaterial.Renderers list attached to your SgtAtmosphere GameObject.




Aurora

The Aurora feature allows you to add a animated aurora ribbons above a planet's surface.


Making an Aurora

Begin by right clicking in your Hierarchy and selecting: Space Graphics Toolkit > Aurora

Or from the menu bar: GameObject > Space Graphics Toolkit > Aurora

NOTE  If you want to add this on top of an existing GameObject (e.g. your planet), then right click your object, or select it before using the menu.

Your scene should now contain a new selected GameObject called Aurora with the SgtAurora component.

Next, you can click the the "Add MainTex" button. This will add the SgtAuroraMainTex component to your Aurora GameObject.

NOTE  There are many settings in these components, and it's not always easy to explain what they do. To understand what they do I recommend you read the individual documentation for each setting (or read the tooltips), and then adjust it to see what visual change it makes. This is easiest to do if you open the aurora feature example scenes.



Backdrop

The Backdrop feature allows you to make background stars, clouds, and other visuals. This is achieved using static billboards that face and always follow the camera. These are very good for backgrounds because:

1 - They are very efficient to render, because there is very little overdraw (unless you increase the individual billboard size too much).

2 - Each billboard can have its own texture, so even when you zoom in there is exceptional detail, unlike with skyboxes.

3 - They look great in VR, because the billboards are static and look consistent from all angles, unlike particle billboards.

4 - They consume very little memory, because each billboard is just 4 vertices.


Making a Backdrop

Begin by right clicking in your Hierarchy and selecting: Space Graphics Toolkit > Backdrop

Or from the menu bar selecting: GameObject > Space Graphics Toolkit > Backdrop

NOTE  If you want to add this on top of an existing GameObject, then right click your object, or select it before using the menu.

Your scene should now contain a new selected GameObject called Backdrop with the SgtBackdrop component.

Next, you need to set the SgtBackdrop.MainTex setting. This can be any texture, or atlas of textures.

NOTE  This effect uses additive blending, so your texture background should be black with no transparency.


Power RGB

This setting can be used with stars. This retains the bright white color in the center, and allows you to tint only the edges with the star color.



Clamp Size

When billboards get too small they tend to flicker, which looks bad. The SgtBackdrop.ClampSize setting can be used to avoid this by limiting the size, and any billboards falling under this size will be faded proportional to the size they would otherwise have been.




Belt

The Belt feature allows you to make rings of asteroids that orbit in circles. These asteroids are rendered with such high performance that you can have tens of thousands of them at once, but this does come with the limitation that you can't interact with them.


Making a Belt

Begin by right clicking in your Hierarchy and selecting: Space Graphics Toolkit > Belt Simple

Or from the menu bar: GameObject > Space Graphics Toolkit > Belt Simple

NOTE  If you want to add this on top of an existing GameObject (e.g. your planet), then right click your object, or select it before using the menu.

Your scene should now contain a new selected GameObject called "Belt Simple" with the SgtBeltSimple component.

NOTE  There are many settings in this component. To understand what they do I recommend you read the individual documentation for each setting (or read the tooltips), and then adjust it to see what visual change it makes. This is easiest to do if you open the belt example scenes.



Billboard

The Billboard feature allows you to make quads that always face the camera. This is useful for rendering distant stars that you can never land on, but still want to have look good when fairly close. While billboards are typically very simple, their implementation in SGT gives you lots of advanced features, like tracking the camera's roll, fading out behind solid objects, and rotation to avoid distortion when not looking at them directly.


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\Basic Toolkit\Textures\Baked Flare A 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.

NOTE  Because the SgtBillboard component takes over the GameObject's rotation, you shouldn't have any components on this GameObject that rely on the rotation (e.g. directional light).


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.



Sprite Billboard Flares

Step 3 - 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, follow step 1 again, but this time drag and drop the sprite onto the sprite GameObject you created earlier. This will add a new sprite

as a child of your existing sprite.

Similar to step 2, you 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.

NOTE  Your parent GameObject already has the SgtBillboard component that controls the rotation, so your second layer doesn't need it.


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, begin by changing the Layer of all your billboard GameObjects to Ignore Raycast.

Next, right click your Hierarchy window and select Space Graphics Toolkit > Depth Camera, your scene should now have a Depth Camera GameObject.

Next, add the SgtDepthScale component to your second billboard layer. This component will use the Depth Camera you added earlier to

calculate how much it should shrink the current GameObject based on the optical thickness (occlusion) between the camera, and the light flare.

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.

If not, try adjusting the SgtDepthCamera component's Size setting. This value is in world space and should correspond to your scene scale.

You can also examine the Sprite Billboard Flare demo scenes to see how they're setup.




Cloudsphere

The Cloudsphere feature allows you to add a layer of clouds around your planets.

To understand how this works, I recommend you check out the demo scenes inside the Features/Cloudsphere folder.



Corona

The Corona feature allows you to add a volumetric atmosphere above a star's surface.


Step 1 - Make a Sphere

You can use a basic Unity sphere for this. For example, right click in the Hierarchy window, and select 3D Object > Sphere, and your scene will have a new Sphere GameObject.

If you want an even rounder sphere, I recommend you use the Geosphere40 mesh that comes with SGT. Keep in mind the SGT sphere has a radius of 1.0 unit, whereas the default Unity one has a radius of 0.5, so your collider settings may need updating.



Step 2 - Add a Corona

Right click your Sphere GameObject in the Hierarchy window, and select Space Graphics Toolkit > Corona, your sphere will now have the

Corona GameObject added as a child, with the SgtAtmosphere and SgtSharedMaterial components.



Step 3 - Set up the Corona

At the bottom of the SgtCorona component in the Inspector window, you will see 3 buttons. If you click these, then your corona will automatically be set up using basic values.

The first button adds the SgtCoronaDepthTex component, which will automatically generate the Inner Depth Tex and Outer Depth Tex settings for your SgtCorona.

The second button sets the Outer Mesh to use the Geosphere40 mesh, as well as calculate the Outer Mesh Radius.

The third button adds your basic sphere from step 1 into the SgtSharedMaterial.Renderers list, and calculates the Inner Mesh Radius field.

This renderers list lets the SgtCorona know which renderers you want the corona material to be applied to.



Step 4 - Done

You now have a basic corona with a fully volumetric atmosphere, so your camera can seamlessly travel from space to the surface.

I recommend you now experiment with all the corona settings to understand what they alter. If you're unsure what a particular setting does, then hover your mouse over the field to see a tooltip, or read the associated documentation file.

NOTE  If you're using the floating origin system then you also need to add the SgtFloatingPoint and SgtFloatingObject components.


Optional Step - Adding Prominences

A sphere with a corona looks nice, but to make it look more interesting you can add prominences around it to make the corona look less regular.

To add one, right click your Sphere GameObject in the Hierarchy window, and select Space Graphics Toolkit > Prominence, your sphere will now have the Prominence GameObject added as a child, with the SgtProminence component.

You can set the Main Tex setting of the SgtProminence component to the Prominence texture that comes with SGT, and adjust the RadiusMin/Max settings.



Optional Step - Procedurally Animated Surface

If you want the surface of your star to be procedurally animated, then you can use one of the materials in the Star Pack/Materials folder/directory. If you want to customize the material then I recommend you duplicate one of these materials first.

To use it, simply find the MeshRenderer component in the inspector window for your Sphere GameObject, expand the Materials array, and

drag and drop your new material over the Element 0 slot.




Debris

The Debris feature allows you to procedurally spawn debris/dust/asteroids and other small objects around the camera.

This feature comes with two debris spawning components, which both implement debris spawning using different strategies.


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

The Flare feature allows you to generate star flares that can be combined with the Billboard feature. These flares are generated using a combination of a custom mesh, and a gradient texture. This allows you to generate very large and detailed flares that use very little GPU memory, unlike typical billboard textures.

Most of the SGT demo scenes have impressive looking star billboards that use the Sprite Renderer component with a large texture. You can

replace these by deleting the Sprite Renderer component, and following the steps below to replace it.


Step 1 - Add a Flare

Right click in the Hierarchy window and select Space Graphics Toolkit > Flare, you should now see a Flare GameObject with the SgtFlare component attached.



Step 2 - Set up the Flare

At the bottom of the SgtFlare component in the Inspector window, you will see two buttons. If you click these then your flare will be set up with basic values.

The first button adds the SgtFareMesh component, which generates the SgtFlare component's Mesh setting.

The second button adds the SgtFareMaterial component, which generates the SgtFlare component's Material setting.



Step 3 - Done!

You now have a basic flare that uses very little texture memory.

To make it look more impressive you can enable the Wave and/or Noise setting in the SgtFlareMesh component. I recommend you

experiment with all of these settings until you get a visual result you're happy with.



Optional Step - Make it a Billboard

By default the flare will remain static and flat. To make it look better it needs to rotate toward the camera to become a billboard. To do this, you can add the SgtBillboard component on the Flare GameObject.

If your flare is very large or your camera gets very close to the flare then I recommend you enable the Avoid Clipping setting.

NOTE  If your scene has many billboards then I recommend you replace the SgtBillboard with SgtFastBillboard, and add a SgtFastBillboardManager to your scene.


Optional Step - Make it Render In Front

By default the flare will render like a normal transparent object, but to make it look really bright it should render in front of everything. To do this, change the Z Test setting to Always, and change the Render Queue setting to Overlay (4000).

If you do this then I recommend you also use the SgtDepthScale component combined with SgtDepthCamera, and set the flare's layer to Ignore Raycast. You can read the Camera Depth Flares tutorial inside the Bonus Pack for more information.




Jovian

The Jovian feature allows you to create volumetric gas giant planets.


Step 1 - Add a Jovian

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



Step 2 - Set Up The Jovian

At the bottom of the SgtJovian component, you can see the the Add DepthTex button, if you click this then the SgtJovianDepthTex component will be added. This component generates the DepthTex setting for you.

If you click the Set Mesh & MeshRadius button, then the Mesh setting will be set to the Geosphere40 mesh, and the MeshRadius setting will be calculated based on this mesh.

You then have to specify the MainTex setting, which should be a cubemap of your gas giant surface texture. You can generate cube maps from normal cylindrical (equirectangular) textures from the texture input settings in the inspector.



Step 3 - Done!

You now have a basic gas giant. The gas giant atmosphere is fully volumetric, so your camera can seamlessly travel from space through the atmosphere.

I recommend you now experiment with all the jovian settings to understand what they alter. If you're unsure what a particular setting does, then hover your mouse over the field to see a tooltip, or read the associated documentation file.

NOTE  If you're using the floating origin system then you also need to add the SgtFloatingPoint and SgtFloatingObject components.


Optional Step - Adding Lighting

To add lighting to your gas giant, first enable the Lit setting, and then click the Add LightingTex button.

Next, you need to let the jovian know which lights you want to use. To do this, add the SgtLight component to your main scene light (By default this will be the Directional Light GameObject).

NOTE  Adding lighting means the nearest shadow will also be received by the gas giant.


Optional Step - Casting Shadows

If you want this planet to cast shadows using the SGT shadow system (e.g. so it can cast on rings), then add the SgtShadowSphere component alongside the SgtJovian component.

To make the shadows look correct the Radius Min/Max values should be similar to the SgtJovian component's Radius setting.




Lightning

The Lightning feature allows you to add a layer of animated lightning to your planets. The lightning is procedurally spawned around the planet from a set list of lightning textures. The lightning texture stores how the lightning animates over time, giving you very high performance.

Section: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.

NOTE  For best results the Red channel (shape), should be thinner than the Green and Blue channels, otherwise you might get visual artifacts around the edges of your lightning shape as it animates.


Planet

The Planet feature allows you to render terrestrial planets like Earth, Mars, etc.

The SGT / Planet shader is specifically designed for rendering high quality planets. Using an Albedo, Normal, and Height texture as a base, this shader can greatly enhance them with distortionless detail textures, a dynamic water level, and much more.

The SgtPlanet component allows you to render planets using the aforementioned SGT / Planet shader. This component adds extra information to the planet mesh that is necessary for correct rendering with this shader. This component also allows you to deform the planet mesh using the heightmap in the planet material, as well as adjust the water level.


SGT 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/SGT 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 (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.

NOTE  This texture will be used to modify the planet mesh if you enable displacement.

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 / 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.

DETAIL

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

This is the world space distance where this detail layer will begin to fade out. This is useful because detail normal maps can look incorrect up close.

NOTE  The last detail map layer should use a Fade Range value of 0, so it doesn't fade out.

DETAIL / Strength R/G/B/A

The allows you to set the normal map strength of each normal map in this layer.

DETAIL / Normal R/G/B/A

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

NIGHT

This allows you to add night lights to your planet.

NOTE  This requires the planet material to be rendered using the SgtPlanet component.
NOTE  This requires your main scene light to have the SgtLight component attached to it.

NIGHT / Texture (RGB)

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

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.

WATER

This allows you to render water on the planet surface.

NOTE To control the water color you should add the SgtPlanetWaterGradient component alongside your SgtPlanet component.
NOTE To control the water texture you should add the SgtPlanetWaterTexture component alongside your SgtPlanet component.

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.

NOTE  This component bakes the water level into the mesh, so it can be expensive to change this in game. It's especially expensive if you specify a MeshCollider.

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

The Prominence feature allows you to render animated streaks coming off the surface of your stars. This feature can also be used to render fictional vortex like effects.

To understand how this works, I recommend you check out the demo scenes inside the Features/Prominence folder.



Ring

The Ring feature allows you to add high detail planetary rings to your planets.


Step 1 - Make Your Planet

This step is optional, but I recommend you first make a planet to put the ring around by following the Making a Terrestrial Planet or Making a Gas Giant tutorials.



Step 2 - Add a Ring

Right click your planet GameObject in the Hierarchy window (or just right click if you don't have one), and select Space Graphics Toolkit > Ring, you should now see a Ring GameObject with the SgtRing component attached.



Step 3 - Set up the Ring

At the bottom of the SgtRing component in the inspector window, you will see the Add Mesh button, clicking this will add the SgtRingMesh component.

You should now see a ring in your Scene or Game window. Feel free to adjust the Radius Min/Max values of this new component to adjust the visual size until it looks good.

Next, you need to set the Main Tex setting to a texture of your ring. This should be a transparent texture.

NOTE  If your ring texture doesn't have transparency, then you can add the SgtRingMainTexFilter component, which will generate a transparent Main Tex for you based on a normal RGB ring texture. This is very useful if you need to make a transparent ring from space

pictures of rings (e.g. Saturn) that don't have transparency.



Step 4 - Done!

You should now have a basic ring.



Optional Step - Adding Lighting

To add lighting to your ring, first enable the Lit setting, and then click the Add LightingTex button.

Next, you need to let the ring know which lights you want to use. To do this, add the SgtLight component to your main scene light (By default this will be the Directional Light GameObject).

NOTE  Adding lighting means the nearest shadow will also be received by the ring.


Optional Step - Casting Shadows

If you want this ring to cast shadows using the SGT shadow system (e.g. so it can cast on planets), then add the SgtShadowRing component to the same GameObject as the SgtRing component.

To make the shadows look correct the Radius Min/Max values should be similar to the SgtRingMesh component's Radius Min/Max settings.




Singularity

The Singularity feature allows you to add gravitational lensing effects to you scene. This is where dense objects can cause light to bend around them, as seen around black holes.

This feature is implemented in two ways, using the the SgtBlackHole, and the SgtLens components.

The main difference between these two implementations is that SgtBlackHole works in screen space, and SgtLens works in world space from a fixed point. Rendering in screen space works well, but it cannot warp near the edges of the screen, because the pixels that should appear there are outside of the screen view, and therefore don't exist. Rendering in world space gives you consistent results regardless of camera angle, but because it's rendered from a single point it cannot accurately render objects that are close to it (due to a high degree of parallax). Also, the world space rendering is done using a cubemap that is baked from your scene, which means the cubemap must be updated if your scene changes, which can be expensive to do. Therefore, if your scene is frequently changing, or there are objects nearby to the black hole, then you should use SgtBlackHole instead.


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).

NOTE  If you're using URP, then you must go to your RenderPipelineAsset settings, and enable the Opaque Texture rendering.


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.




Spacetime

The Spacetime feature allows you to render a grid that can be deformed by gravitational bodies, including gravitational waves from orbiting black holes.


Step 1 - Make a Spacetime

Right click in your Hierarchy window, and select Space Graphics Toolkit > Spacetime, and you should see a new Spacetime GameObject in your scene with the SgtSpacetime and SgtSharedMaterial components attached.

You can now set the Main Tex setting in the SgtSpacetime component to the Grid texture that comes with SGT.



Step 2 - Make a Grid

For the spacetime effect to render, you need to make a grid that it will be displayed on. You can use Unity's built-in Plane for this by right clicking in the Hierarchy window, and selecting 3D Object > Plane, and your scene will have a new Plane GameObject. If you want a higher detail plane with a more sensible size (+- 1 unit), then you can use the Plane100 mesh that comes with SGT.

You can use as many GameObjects as you like to render the effect. Also keep in mind they don't have to be flat planes, you can use a sphere or box or anything you like, as long as it has enough vertices to deform correctly.



Step 3 - Remove Grid Renderers

The spacetime effect works by adding a new material to your grid renderers, so unless you really want a second material, I recommend you remove any materials used by your grid. To do this, find the MeshRenderer component on each of your grid GameObjects, expand the Materials array, and set the Size setting to 0 and press Enter on your keyboard.



Step 4 - Link Grid Renderers

Now that you have removed all grid renderer materials, it's time to add the spacetime one. To do this, find the SgtSharedMaterial component on your Spacetime GameObject, find the Renderers setting, and drag and drop each of your grid GameObjects from the Hierarchy window to this list. If you do it correctly, it should display an add [+] icon, and automatically add them to the list. Do this for all your grid GameObjects.



Step 5 - Add Wells

To make the spacetime effect display curvature, you need to add gravitational wells. To do this, right click in your Hierarchy window, and select Space Graphics Toolkit > Spacetime Well, and you should see a new Spacetime Well GameObject in your scene with the SgtSpacetimeWell component attached.

You should now see your spacetime deform. If not, adjust the position to ensure it's on or near the grid, or try adjust the Radius setting so it's large enough.



Step 6 - 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.




Star

The Star feature allows you to render star surfaces with a procedurally animated surface.


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.

NOTE This texture should use equirectangular (cylindrical) projection, and have Wrap Mode: U axis = Repeat, V axis = Clamp.

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.

NOTE This texture should use equirectangular (cylindrical) projection, and have Wrap Mode: U axis = Repeat, V axis = Clamp.

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.

NOTE This texture should use equirectangular (cylindrical) projection, and have Wrap Mode: U axis = Repeat, V axis = Clamp.

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

The Starfield feature allows you render a wide range of effects involving a large amount of stars. For example, elliptical galaxies, spiral galaxies, and even starfield warp effects.

To understand how these work, I recommend you look at the demo scenes inside the Features/Starfield folder.



Terrain

The Terrain feature allows you to render high resolution planets with a dynamic surface mesh that increases in detail based on camera distance. This is suitable for large planets (e.g. greater than 1km radius), and can even be used to render planets as large as Earth. If your planets don't need to be so large or they're only viewed from far away then I recommend you instead use the SgtPlanet component from the Planet feature, because it's much simpler to use.


Basic Setup

Begin by creating a terrain planet.

METHOD 1 Right click the Hierarchy tab, and select: Space Graphics Toolkit > Terrain Planet.
METHOD 2 Click the menu bar option: GameObject > Space Graphics Toolkit > Terrain Planet.
METHOD 3 Manually create a new GameObject, and add the Sgt Terrain Planet and Sgt Terrain Planet Material components.

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

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

NOTE  This should be a material that uses the SGT / Terrain Planet shader. You can use one of the example materials for this.


SGT 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.



SGT Terrain Ocean Shader

The terrain feature comes with the SGT / Terrain Ocean shader, which is specifically designed to be used with the SgtTerrainPlanet 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.

NOTE  This material should be rendered using the SgtTerrainOceanMaterial component, NOT the normal SgtTerrainPlanetMaterial component used for the normal terrain.
NOTE  The ocean rendering required a camera Depth Texture to work. This can be done by adding the SgtDepthTextureMode component to your camera(s), and setting the DepthMode to Depth, or similar.

TRANSPARENCY

This allows you to change the colot/opacity of the ocean based on its depth.

TRANSPARENCY / Refraction

This allows you to change how much the normal map bends light through the water.

TRANSPARENCY / Opacity Range

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

TRANSPARENCY / Opacity 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 / Shore Range

This works like Opacity Range, but is a applied as a second layer. This allows you to fade the shore out abruptly to avoid sharp transitions at the shoreline.

TRANSPARENCY / Deep Range

This works like Opacity Range, but it will only modify the ocean color.

TRANSPARENCY / Deep Range

This works like Opacity Power, but it will only modify the ocean color distribution.

TRANSPARENCY / Deep Color

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



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.




Thruster

The Thruster feature allows you to create spaceship thrusters that apply Newtonian forces to your spaceship, as well as render a basic thruster effect.


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.

NOTE  By default the Throttle value is 0, which means the SgtThrusterScale component will make the scale 0,0,0. To test what different thrust values look like, set the Throttle value to 1.


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.




Universe

The Universe feature allows you implement a floating origin system into your scene.


What is a Floating Origin System?

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 this floating origin system, 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 with a floating origin system, 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 this floating origin system 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.

NOTE  You cannot nest SgtFloatingObject and SgtFloatingCamera components (e.g. parent & child). If you want one to follow the other then you must separate them, and use the SgtFloatingFollow component to connect them again. While it's technically possible to support this, it makes the code a lot more complicated and will result in reduced performance.


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.








Assets

Here's a list of all my other assets, please check them out!

You can also view this list on my Asset Store page.

Lean GUI

Lean GUI

Lean GUI is a colllection of components that extend Unity's GUI system, allowing you to rapidly enhance the user experience (UX) of your game's UI.


Lean Transition

Lean Transition

Quickly polish your games using Lean Transition. This asset allows you to easily tween or animate almost anything in your game, making it transition smoothly.


Paint in 3D

Paint in 3D

Paint all your objects using Paint in 3D - both in game, and in editor. All features are optimized with GPU accelerated texture painting, so you can enjoy consistent performance, even if you paint your objects one million times!


Lean Pool

Lean Pool

Quickly optimize the performance of your games using Lean Pool. Within minutes you can use this lightweight asset to preload, recycle, and limit the spawning of your prefabs.


Space Graphics Toolkit

Space Graphics Toolkit

Quickly make the space scene of your dreams using Space Graphics Toolkit. This huge collection of space effects can be customized and combined in any way you like, allowing you to quickly make realistic or fantasy worlds. Each feature has been heavily optimized to run on almost any device and platform.


Lean Touch

Lean Touch

Rapidly develop your game with consistent input across desktop & mobile using Lean Touch. This lightweight asset comes with many modular components, allowing you to customize them to your exact project needs!


Lean Localization

Lean Localization

Lean Localization is a localization library that's designed to be as simple to use as possible for both designers, and programmers.


Lean GUI Shapes

Lean GUI Shapes

Lean GUI Shapes allows you to quickly add lines, rounded boxes, polygons, and much more to your GUI!


Destructible 2D

Destructible 2D

Unlock the full potential of your 2D games using Destructible 2D, this asset allows you to quickly convert all your boring solid sprites into fully destructible ones!


Planet Pack - Space Graphics Toolkit

Planet Pack - Space Graphics Toolkit

This pack contains 26 high detail PBR planets, all finished using the powerful planet features of Space Graphics Toolkit (SGT). This is a standalone package, so SGT is not required. You can even use the included features to turn your own planets into beautiful worlds!


Lean Touch+

Lean Touch+

Lean Touch+ is an extension to the popular Lean Touch asset, adding many more example scenes.


Volumetric Audio

Volumetric Audio

Unity sounds only emanate from a single point source. This is great for explosions and footsteps, but quite often you need something more advanced. Volumetric Audio is an easy to use package that allows you to define boxes, spheres, capsules, paths, or meshes that sounds can emanate from.






Versions

3.8.4

Added SGT / Terrain Planet shader.
Added SGT / Terrain Ocean shader.
Added SgtTerrainOceanMaterial component.
Added second detail layer to SGT / Planet shader.
Added up to 4 optional detail channels to SGT / Planet shader.
Added mouse wheel support back to SgtCameraMove component.
Added new tutorial scenes to Terrain feature.
Fixed error in some scenes when using new InputSystem package.
Fixed memory leaks from SgtTerrainPlanet and related components.
Fixed Planet Surfing demo scene spaceship controls.
Simplified SGT / Planet shader detail settings.
Removed water settings from SgtTerrainPlanetMaterial component.



3.8.3

Improved compatibility when upgrading from older versions.



3.8.2

Fixed SgtStarfieldInfinite render issue in HDRP.
Fixed pink materials when reimporting with SRP.
Simplified hierarchy of all demo scenes.



3.8.1

Fixed media pack links in documentation.
Fixed SgtBeltSimple property editing from code.
Fixed build errors.



3.8.0

NOTE  This is a huge update. Back up your project files before installing.

Moved main build to Unity 2019.4.12f1.
Fixed variable SgtJovian.Occlusion setting output.
Added SgtFloaringOrbit.Offset setting.
Fixed SgtFloatingFollow component's rotation handling.
Added SgtBlackHole component to Singularity feature.
Removed SgtSingularity component.
Replaced SGT Planet shader with Planet shader.
Added Has Lights setting to Planet shader.
Added Has Water setting to Planet shader.
Added night lights to Planet shader for all rendering pipelines.
Fixed bug with SgtPlanet when disabling SgtAtmosphere component.
Removed PIPELINE tool (material switching is now automatic).
Fixed atmosphere flickering in HDRP.
Added renderer-specific intensity settings to SgtLight.
Added SgtManager component to scenes to auto modify settings for HDRP.
Renamed SgtLight.Intensity to IntensityInSgt.
Improved demo scenes for the Star feature.
Added Flow settings to SGT Star shader.
Added Sunspots settings to SGT Star shader.
Fixed SgtCorona inspector values not updating.
Added support for new InputSystem package.
Rewrote SgtCameraMove component.
Rewrote SgtCameraLook component.
Added SgtDragSource component.
Added SgtDragReceiver component.



3.7.11

Added SgtStarfieldDome component to Starfield feature.
Added Dome demo scene to Starfield feature.
Added Dome / Bias demo scene to Starfield feature.
Fixed flares appearing pink when using prefabs in builds.



3.7.10

Added SgtRing.Occlusion setting.
Fixed SGT Planet shader default water level when using SRP.
Fixed Singularity feature when using single pass instanced VR rendering.



3.7.9

Added SgtBeltCustom.Occlusion setting.
Fixed SgtBeltSimple.Layout settings not showing.
Fixed SgtStarfieldCustom.Layout settings not showing.
Fixed SgtBeltCustom inspector.



3.7.8

Fixed SgtStarfieldCustom error when changing star count.
Fixed SgtBeltCustom error when changing asteroid count.
Improved Lightning feature documentation and tutorial scenes.
Added more lightning textures.



3.7.7

Fixed WebGL error from texture creating components.
Fixed inspector values not updating from texture creating components.
Fixed potential recursive loop from floating origin system components.
Fixed scene objects appearing in prefab mode.
Fixed scene objects appearing when hidden.
Added SgtJovian.CameraOffset setting.
Added SgtTerrainPlanetMaterial.ClampHeights setting.
Added SgtTerrainPlanet LOD smoothing.
Updated Jovian demo scene to include aurora.
Updated lighting in Earth Sized Planet scene.
Updated lighting in Obsidian Planet scene.



3.7.6

Added Obsidian Planet demo scene.
Added SgtTerrainSimplex.Ridged setting.
Added SgtTerrainSimplex.Seed setting.
Added SgtPlanet.Channel setting.
Added SgtTerrainPlanetMaterial.WaterLevel setting.
Added SgtTerrainPlanetMaterial.HeightmapBias setting.
Added SgtFloatingSpawner.RandomizeIndex setting.
Fixed SgtStarfieldInfinite stretch feature.
Fixed some Basic Pack demo scene materials.
Moved SgtOcclusion code to Shared folder.



3.7.5

Added SgtLight.Intensity setting.
Added SgtTerrainPrefabSpawner.Threshold setting.
Added SgtTerrainPrefabSpawner.SharedMaterial setting.
Updated demo scene background RenderQueue and scale for SRP compatibility.
Improved SRP compatibility documentation.
Fixed single pass stereo VR rendering.
Rewrote Spacetime to be easier to use.



3.7.4

NOTE  This is a massive update. Please back up your project, delete the old SGT folder, then install the new version.

Moved main build to Unity 2018.4.13f1.
Added Terrain feature.
Added SgtFloatingParticleSystem component to Universe feature.
Renamed SgtStaticPlanet to SgtPlanet.
Renamed SgtDepthScale to SgtOcclusionScaler.
Renamed SgtDepth to SgtOcclusion.
Removed SgtDepthCamera component.
Removed SgtDepthRaycast component.
Removed Mie scattering from atmosphere inner shader.
Replaced SgtDynamicPlanet with SgtTerrainPlanet.
Implemented custom occlusion calculations for main components.
Removed automatically created child components for all components.
Improved multi-camera rendering code.
Refactored all code.



3.7.3

Fixed SgtStaticPlanet bounds when layering atmosphere and cloudsphere.
Moved SgtDynamicPlanet back to Planet feature.



3.7.2

Updated documentation.
Added asmdef.
Added Universe/Nested Orbits demo scene.
Moved SgtDynamicPlanet back to Terrain feature.
Fixed SgtStaticPlanet polar UV generation.
Removed auto package dependency install (see documentation).



3.7.1

Fixed SRP bug when using Unity 2018.4.
Removed unnecessary package dependencies.
Added Shared/Camera Controls demo scene.
Added Shared/Rigidbody Controls demo scene.
Improved Basic Pack/Planet Surfing demo scene.
Improved Basic Pack/Terrestrial Planet demo scene.
Improved Basic Pack/Terrestrial Planet + Ring demo scene.
Added SgtFloatingSpeedometer.UpdateIn setting.



3.7.0

Moved main build to Unity 2018.4.0f1.
Added new Planet demo scenes.
Added new Universe demo scenes.
Added Eath Sized Planet demo scene.
Added SgtFloatingWarpPin.FloatingCamera setting.
Added SgtFloatingWarpPin.WorldCamera setting.
Added SgtFloatingSpawner.Range setting.
SgtFloatingCamera no longer needs to be attached to a Camera.
SgtFloatingCamera snapping attempt moved from pre-render to LateUpdate.
Moved Terrain features to Planet folder.
Merged SgtMeshDisplacer into SgtPlanet.
Merged SgtPlanetMeshConverter into SgtPlanet.
Renamed SgtPlanet to SgtStaticPlanet.
Rewrote SgtTerrain to be faster and handle larger scale planets.
Renamed SgtTerrain to SgtDynamicPlanet.
Changed SgtCameraMove.MouseSensitivity to modify movement speed.
Merged SgtFloatingPoint into SgtFloatingCamera.
Merged SgtFloatingPoint into SgtFloatingObject.
Merged SgtFloatingSpawnable into SgtFloatingObject.
Removed SgtFloatingLod component.
Removed SgtFloatingOrigin component.
Removed SgtFloatingCamera.Scale setting.
Improved SgtFloatingCamera snap behavior with larger planets.
Added SgtFloatingFollow component.
Fixed SgtJovian error with _MainTex property.



3.6.9

Fixed SgtStarfieldElliptical.StarRadiusBias being 0 by default.
Improved Billboard5 texture resolution.
Improved Billboard6 texture resolution.
Changed SgtInputManager from a component to a normal class.
Updated all demo scenes.
Added Basic Pack/Elliptical Galaxy demo scene.
Added Basic Pack/Spiral Galaxy demo scene.
Added Basic Pack/Nebula demo scene.
Added Starfield/Box demo scene.
Added Starfield/Box Offset demo scene.
Added Starfield/Box Colors demo scene.
Added Starfield/Box Clouds demo scene.
Added Starfield/Box BlendMode demo scene.
Added Starfield/Box PowerRGB demo scene.
Added Starfield/Box ClampSize demo scene.
Added Starfield/Box Layering demo scene.
Added Starfield/Elliptical demo scene.
Added Starfield/Elliptical Symmetry demo scene.
Added Starfield/Elliptical Offset demo scene.
Added Starfield/Elliptical Bias demo scene.
Added Starfield/Elliptical Layering demo scene.
Added Starfield/Spiral demo scene.
Added Starfield/Spiral Rotation demo scene.
Added Starfield/Spiral Arm Count demo scene.
Added Starfield/Spiral Twist demo scene.
Added Starfield/Spiral Thickness Inner demo scene.
Added Starfield/Spiral Thickness Outer demo scene.
Added Starfield/Spiral Layering demo scene.
Added Starfield/Nebula demo scene.
Added Starfield/Nebula Height Source demo scene.
Added Starfield/Nebula Scale Source demo scene.
Added Starfield/Nebula Jitter demo scene.
Added Starfield/Nebula HorizontalBrightness demo scene.
Added Starfield/Nebula Layering demo scene.
Added Starfield/Infinite demo scene.
Added Starfield/Infinite Far demo scene.
Added Starfield/Infinite Warp demo scene.
Added Starfield/Infinite Dust demo scene.
Added Starfield/Infinite Dust Near demo scene.
Added Starfield/Infinite Floating Camera demo scene.
Added Starfield/Infinite Floating Origin demo scene.



3.6.8

Fixed Accretion Disk billboard flare rendering.
Fixed SgtShadowLayer flickering with SRP.
Fixed SgtDebrisGrid spawning code.
Fixed default SgtStarfieldElliptical.Bias value.
Enabled demo scene billboard Roll To Camera for VR compatibility.
Changed Additive Overlay shader render queue for SRP compatibility.
Added SgtAtmosphere.AmbientColor setting for greater control and SRP compatibility.
Added SgtBelt.AmbientColor setting for greater control and SRP compatibility.
Added SgtCloudsphere.AmbientColor setting for greater control and SRP compatibility.
Added SgtJovian.AmbientColor setting for greater control and SRP compatibility.
Added SgtRing.AmbientColor setting for greater control and SRP compatibility.
Added Rendering Pipeline Switcher tool to root SGT folder.
Added Single-Pass VR support to SgtSingularity.
Added SRP compatibility to SgtSingularity.
Added SgtStarfield.ClampSize feature.
Added VR Stars demo scene to Basic Pack.
Added Water Level demo scene to Basic Pack.



3.6.7

SgtFloatingOrbit no longer notifies of position changes if they didn't occur.
Improved SRP support for components that depend on camera information.
Fixed Planet Pack 1 dependencies.



3.6.6

Updated documentation.
Added SgtSimpleOrbit.
Added SgtThrusterControls.



3.6.5

Updated documentation.
Improved Debris demo scenes and documentation.



3.6.4

Added night light support to the Planet shader.
Added new demo scenes for the Debris feature.
Updated Solar System Pack link.



3.6.3

Fixed shadow casting calculations.
Improved component consistency.
Redesigned documentation.



3.6.2

Updated Solar System Pack for better realism.
Added automatic floating origin support to SgtStarfieldInfinite.
Added SgtCamera.UseOrigin setting for floating origin compatibility.
Added SgtStarfield.StretchLimit to improve warp effects at high speed.







Components

SgtAccretion

This component allows you to render an accretion disc. This disc can be animated to spiral dust into the center. This disc can be split into multiple segments to improve depth sorting.


Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the disc material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



Texture
MainTex

The texture applied to the disc, where the left side is the inside, and the right side is the outside.



Mesh
Mesh

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



int
Segments

This allows you to set how many copies of the Mesh are required to complete the disc. For example, if the Mesh is 1/4 of the disc, then Segments should be set to 4.



bool
Detail

Should the disc have a detail texture? For example, dust noise when you get close.



Texture
DetailTex

This allows you to set the detail texture that gets repeated on the disc surface.



float
DetailScaleX

The detail texture horizontal tiling.



int
DetailScaleY

The detail texture vertical tiling.



Vector2
DetailOffset

The UV offset of the detail texture.



Vector2
DetailSpeed

The scroll speed of the detail texture UV offset.



float
DetailTwist

The amount the detail texture is twisted around the disc.



float
DetailTwistBias

The amount the twisting is pushed to the outer edge.



bool
Near

Enable this if you want the disc to fade out as the camera approaches.



Texture
NearTex

The lookup table used to calculate the fade opacity based on distance, where the left side is used when the camera is close, and the right side is used when the camera is far.



float
NearDistance

The world space distance the fade will begin from.




SgtAccretionMesh

This component allows you to generate the SgtAccretion.Mesh field.


int
Segments

The amount of segments the final disc will be comprised of.



int
SegmentDetail

The amount of triangle edges along the inner and outer edges of each segment.



int
SegmentTiling

The amount of times the main texture is tiled around the ring segment.



float
RadiusMin

The radius of the inner edge in local space.



float
RadiusMax

The radius of the outer edge in local space.



int
RadiusDetail

The amount of edge loops around the generated disc. If you have a very large ring then you can end up with very skinny triangles, so increasing this can give them a better shape.



float
BoundsShift

The amount the mesh bounds should get pushed out by in local space. This should be used with 8+ Segments.



void
ExportMesh

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

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




SgtAccretionNearTex

This component allows you to generate the SgtAccretion.NearTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.



void
ExportTexture

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

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




SgtAtmosphere

This component allows you to draw a volumetric atmosphere. The atmosphere is rendered using two materials, one for the surface (inner), and one for the sky (outer).

The outer part of the atmosphere is automatically generated by this component using the OuterMesh you specify.

The inner part of the atmosphere is provided by you (e.g. a normal sphere GameObject), and is specified in the SgtSharedMaterial component that this component automatically adds.


Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the atmosphere materials. You can normally adjust the render queue in the material settings, but since these materials are procedurally generated your changes will be lost.



Texture
InnerDepthTex

The look up table associating optical depth with atmospheric color for the planet surface. The left side is used when the atmosphere is thin (e.g. center of the planet when looking from space). The right side is used when the atmosphere is thick (e.g. the horizon).



float
InnerMeshRadius

The radius of the meshes set in the SgtSharedMaterial.



Texture2D
OuterDepthTex

The look up table associating optical depth with atmospheric color for the planet sky. The left side is used when the atmosphere is thin (e.g. edge of the atmosphere when looking from space). The right side is used when the atmosphere is thick (e.g. the horizon).



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 thick the atmosphere is when the camera is inside its radius.



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.



bool
Lit

If you enable this then nearby SgtLight and SgtShadow casters will be found and applied to the lighting calculations.



Color
AmbientColor

The atmosphere will always be lit by this amount.



Texture
LightingTex

The look up table associating light angle with surface color. The left side is used on the dark side, the middle is used on the horizon, and the right side is used on the light side.



bool
Scattering

If you enable this then light will scatter through the atmosphere. This means light entering the eye will come from all angles, especially around the light point.



bool
GroundScattering

If you enable this then atmospheric scattering will be applied to the surface material.



Texture
ScatteringTex

The look up table associating light angle with scattering color. The left side is used on the dark side, the middle is used on the horizon, and the right side is used on the light side.



float
ScatteringStrength

The scattering is multiplied by this value, allowing you to easily adjust the brightness of the effect.



float
ScatteringMie

The Mie scattering term, allowing you to adjust the distribution of front scattered light.



float
ScatteringRayleigh

The Rayleigh scattering term, allowing you to adjust the distribution of front and back scattered light.



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.




SgtAtmosphereDepthTex

This component allows you to generate the SgtAtmosphere.InnerDepthTex and SgtAtmosphere.OuterDepthTex fields.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.




SgtAtmosphereHeight

This component modifies the SgtAtmosphere.Height based on camera proximity.


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.




SgtAtmosphereLightingTex

This component allows you to generate the SgtAtmosphere.LightingTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.




SgtAtmosphereScatteringTex

This component allows you to generate the SgtAtmosphere.ScatteringTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.




SgtAurora

This component allows you to render an aroura above a planet. The aurora can be set to procedurally animate in the shader.


Texture
MainTex

The base texture tiled along the aurora.



Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the aurora material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



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.



bool
Near

Should the aurora fade out when the camera gets near?



Texture
NearTex

The lookup table used to calculate the fading amount based on the distance, where the left side is used when the camera is near, and the right side is used when the camera is far.



float
NearDistance

The distance the fading begins from in world space.



bool
Anim

Should the aurora paths animate?



float
AnimOffset

The current age/offset of the animation.



float
AnimSpeed

The speed of the animation.



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.




SgtAuroraMainTex

This component allows you to generate the SgtAurora.MainTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition. This stores the noise samples.



int
Height

The height of the generated texture. A higher value can result in a smoother transition. This stores the vertical color samples.



TextureFormat
Format

The format of the generated texture.



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.




SgtAuroraNearTex

This component allows you to generate the SgtAurora.NearTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



SgtEase.Type
Ease

The ease type used for the transition.



float
Sharpness

The sharpness of the 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 SgtAurora component's NearTex setting using the exported asset.




SgtBackdrop

This component allows you to generate procedurally placed quads on the edge of a sphere.

The quads can then be textured using clouds or stars, and will follow the rendering camera, creating a backdrop.

This backdrop is very quick to render, and provides a good alternative to skyboxes because of the vastly reduced memory requirements.


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).



bool
PowerRgb

Instead of just tinting the stars with the colors, should the RGB values be raised to the power of the color?



bool
ClampSize

Prevent the quads from being too small on screen?



float
ClampSizeMin

The minimum size each star can be on screen in pixels. If the star goes below this size, it loses opacity proportional to the amount it would have gone under.




SgtBackdropQuad

This class stores data for one quad generated by SgtBackdrop, this is typically procedurally generated.


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.




SgtBelt

This base class contains the functionality to render an asteroid belt.


float
OrbitOffset

The amount of seconds this belt has been animating for.



float
OrbitSpeed

The animation speed of this belt.



bool
Lit

If you enable this then nearby SgtLight and SgtShadow casters will be found and applied to the lighting calculations.



Texture
LightingTex

The look up table associating light angle with surface color. The left side is used on the dark side, the middle is used on the horizon, and the right side is used on the light side.



Color
AmbientColor

The belt will always be lit by this amount.



bool
PowerRgb

Instead of just tinting the asteroids with the colors, should the RGB values be raised to the power of the color?




SgtBeltAsteroid

This stores all information about an asteroid in an SgtBelt___ component.


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.




SgtBeltCustom

This component allows you to specify the exact position/size/etc of each asteroid in this asteroid belt.


float
Occlusion

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



List<SgtBeltAsteroid>
Asteroids

The custom asteroids in this belt.

NOTE  If you modify this then you must then call the DirtyMesh method.



SgtBeltLightingTex

This component allows you to generate the SgtBelt.LightingTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.




SgtBeltSimple

This component allows you to generate an asteroid belt with a simple exponential distribution.


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).




SgtBillboard

This component turns the current GameObject into a billboard.

NOTE  If you're using the floating origin system then you should use the SgtFloatingBillboard component instead.

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.




SgtFastBillboard

This component rotates the current Gameobject to the rendering camera.


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.




SgtFastBillboardManager

All SgtFastBillboards will be updated from here.



SgtCloudsphere

This component allows you to render a sphere around a planet with a cloud cubemap.


Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the cloudsphere material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



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.



Cubemap
MainTex

The cube map applied to the cloudsphere surface.



Texture2D
DepthTex

The look up table associating optical depth with cloud color. The left side is used when the depth is thin (e.g. edge of the cloudsphere when looking from space). The right side is used when the depth is thick (e.g. center of the cloudsphere when looking from space).



float
Softness

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



bool
Lit

If you enable this then nearby SgtLight and SgtShadow casters will be found and applied to the lighting calculations.



Texture
LightingTex

The look up table associating light angle with surface color. The left side is used on the dark side, the middle is used on the horizon, and the right side is used on the light side.



Color
AmbientColor

The cloudsphere will always be lit by this amount.



bool
Near

Enable this if you want the cloudsphere to fade out as the camera approaches.



Texture
NearTex

The lookup table used to calculate the fade opacity based on distance, where the left side is used when the camera is close, and the right side is used when the camera is far.



float
NearDistance

The distance the fading begins from in world space.



bool
Detail

Enable this if you want the cloud edges to be enhanced with more detail.



Texture
DetailTex

This allows you to set the detail map texture, the detail should be stored in the alpha channel.



float
DetailScale

This allows you to set how many times the detail texture is repeating along the cloud surface.



float
DetailTiling

This allows you to set how many times the detail texture is repeating along the cloud surface.



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.




SgtCloudsphereDepthTex

This component allows you to generate the SgtCloudsphere.DepthTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.




SgtCloudsphereLightingTex

This component allows you to generate the SgtCloudsphere.LightingTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.




SgtCloudsphereNearTex

This component allows you to generate the SgtCloudsphere.NearTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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.



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.




SgtCorona

This component allows you to draw a volumetric corona around a sphere.


Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the corona materials. You can normally adjust the render queue in the material settings, but since these materials are procedurally generated your changes will be lost.



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 corona, giving you fine control over the render order.



Texture
InnerDepthTex

The look up table associating optical depth with coronal color for the star surface. The left side is used when the corona is thin (e.g. center of the star when looking from space). The right side is used when the corona is thick (e.g. the horizon).



float
InnerMeshRadius

The radius of the inner renderers (surface) in local coordinates.



Texture2D
OuterDepthTex

The look up table associating optical depth with coronal color for the star sky. The left side is used when the corona is thin (e.g. edge of the corona when looking from space). The right side is used when the corona is thick (e.g. the horizon).



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 corona will render incorrectly.



float
OuterSoftness

Should the outer corona fade out against intersecting geometry?



float
Height

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



float
InnerFog

If you want an extra-thin or extra-thick density, you can adjust that here (0 = default).



float
OuterFog

If you want an extra-thin or extra-thick density, you can adjust that here (0 = default).



float
Sky

This allows you to control how thick the corona is when the camera is inside its radius.



float
OuterRadius

This property tells you the outer radius of the corona based on the InnerMeshRadius and Height settings.



Transform
CachedTransform

This property gives you the Transform component alongside this component.



SgtSharedMaterial
CachedSharedMaterial

This property gives you the SgtSharedMaterial component alongside this component.




SgtCoronaDepthTex

This component generates the SgtCorona.InnerDepthTex and SgtCorona.OuterDepthTex textures.


int
Width

The resolution of the surface/space optical thickness transition in pixels.



TextureFormat
Format

The format of the generated texture.



Color
HorizonColor

The horizon color for both textures.



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 SgtCorona component's InnerDepthTex 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 SgtCorona component's OuterDepthTex setting using the exported asset.




SgtDebris

This component handles a single debris object.


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.




SgtDebrisGrid

This component allows you to spawn debris prefabs around a target point (e.g. camera), where each debris object must lie inside a grid square, allowing you to evenly distribute debris over the scene.


Transform
Target

The transform the debris will spawn around (e.g. MainCamera).



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 decreated 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 debis 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.




SgtDebrisSpawner

This component allows you to randomly spawn debris around the camera over time.


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.




SgtFlare

This component allows you to generate a high resolution mesh flare.


Mesh
Mesh

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



Material
Material

The material used to render this 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.




SgtFlareMaterial

This component allows you to generate the material and texture for an SgtFlare.


ZTestState
ZTest

The ZTest mode of the material (LEqual = default, Always = draw on top).



DstBlendState
DstBlend

The ZTest mode of the material (One = Additive, OneMinusSrcColor = Additive Smooth).



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the flare material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



TextureFormat
Format

The format of the generated texture.



int
Width

The width of the generated texture. A higher value can result in a smoother transition.



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.




SgtFlareMesh

This component allows you to generate the SgtFlare.Mesh field.


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.




SgtJovian

This component allows you to render volumetric jovian (gas giant) planets.


Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the jovian material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



float
CameraOffset

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



Cubemap
MainTex

The cube map used as the base texture for the jovian.



Texture2D
DepthTex

The look up table associating optical depth with atmosphere color. The left side is used when the atmosphere is thin (e.g. edge of the jovian when looking from space). The right side is used when the atmosphere is thick (e.g. the center of the jovian when looking from space).



Cubemap
FlowTex

The cube map used to define how the MainTex should flow across the surface of the jovian.



float
FlowSpeed

The speed of the jovian texture flow.



float
FlowStrength

The maximum distance the jovian texture can flow in UV space.



float
FlowNoiseTiling

The flow texture timing will be offset using noise, and this setting allows you to specify the resolution of that noise.



float
Sky

This allows you to control how thick the atmosphere is when the camera is inside its radius.



bool
Lit

If you enable this then nearby SgtLight and SgtShadow casters will be found and applied to the lighting calculations.



Texture
LightingTex

The look up table associating light angle with surface color. The left side is used on the dark side, the middle is used on the horizon, and the right side is used on the light side.



Color
AmbientColor

The jovian will always be lit by this amount.



bool
Scattering

If you enable this then light will scatter through the jovian atmosphere. This means light entering the eye will come from all angles, especially around the light point.



Texture
ScatteringTex

The look up table associating light angle with scattering color. The left side is used on the dark side, the middle is used on the horizon, and the right side is used on the light side.



float
ScatteringStrength

The scattering is multiplied by this value, allowing you to easily adjust the brightness of the effect.



Mesh
Mesh

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



float
MeshRadius

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



float
Radius

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



float
DistanceRadius

This allows you to set the radius of the jovian in local space when using distance calculations. Distance calculations normally tell you how far from the surface of a planet you are, but since a jovian isn't solid, you may want to customize this based on your project.




SgtJovianDepthTex

This component allows you generate the SgtJovian.DepthTex field. If you want to improve performance then you can use the context menu to export the texture and manually apply it.


int
Width

The resolution of the optical depth color. A higher value can result in smoother results.



TextureFormat
Format

The format of the generated texture.



SgtEase.Type
RimEase

The rim transition style.



float
RimPower

The rim transition sharpness.



Color
RimColor

The rim color.



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 SgtJovian component's DepthTex setting using the exported asset.




SgtJovianLightingTex

This component allows you generate the SgtJovian.LightingTex field. If you want to improve performance then you can use the context menu to export the texture and manually apply it.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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 SgtJovian component's LightingTex setting using the exported asset.




SgtJovianScatteringTex

This component allows you generate the SgtJovian.ScatteringTex field. If you want to improve performance then you can use the context menu to export the texture and manually apply it.


int
Width

The resolution of the day/sunset/night color transition in pixels. A higher value can result in smoother results.



int
Height

The resolution of the scattering transition in pixels.



TextureFormat
Format

The format of the generated texture.



float
Mie

The sharpness of the forward scattered light.



float
Rayleigh

The brightness of the front and back scattered light.



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 SgtJovian component's ScatteringTex setting using the exported asset.




SgtLightning

This component handles rendering of lightning spawned from the SgtLightningSpawner component.


SgtLightningSpawner
LightningSpawner

The lightning spawner this belongs to. If this is null then this GameObject will automatically be destroyed.



float
Age

The maximum amount of seconds this lightning has been active for.



float
Life

The maximum amount of seconds this lightning can be active for.




SgtLightningSpawner

This component allows you to spawn animated lightning sprites around a planet.


float
DelayMin

The minimum delay between lightning spawns.



float
DelayMax

The maximum delay between lightning spawns.



float
LifeMin

The minimum life of each spawned lightning.



float
LifeMax

The maximum life of each spawned lightning.



float
Radius

The radius of the spawned lightning mesh in local coordinates.



float
Size

The size of the lightning in degrees.



int
Detail

The amount of rows and columns in the lightning mesh.



Gradient
Colors

When lightning is spawned, its base color will be randomly picked from this gradient.



float
Brightness

The lightning color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



List<Sprite>
Sprites

The random sprite used by the lightning.




SgtPlanet

This component allows you to render a planet that has been displaced with a heightmap, and has a dynamic water level.


Mesh
Mesh

The sphere mesh used to render the planet.



// int
RenderingLayer

The rendering layer used to render the planet.



MeshCollider
MeshCollider

If you want the generated mesh to have a matching collider, you can specify it here.



float
Radius

The radius of the planet in local space.



Material
Material

The material used to render the planet. For best results, this should use the SGT Planet shader.



SgtSharedMaterial
SharedMaterial

If you want to apply a shared material (e.g. atmosphere) to this terrain, then specify it here.



float
WaterLevel

The current water level.

0 = Radius.

1 = Radius + Displacement.



bool
Displace

Should the planet mesh be displaced using the heightmap in the planet material?



float
Displacement

The maximum height displacement applied to the planet mesh when the heightmap alpha value is 1.



bool
ClampWater

If you enable this then the water will not rise, instead the terrain will shrink down.



void
Rebuild

This method causes the planet mesh to update based on the current settings. You should call this after you finish modifying them.




SgtPlanetWaterGradient

This component can be added alongside the SgtPlanet component to give it an animated water surface texture.


Color
Shallow

The color of shallow water.



Color
Deep

The color of deep water.



SgtEase.Type
Ease

The way the color transitions between shallow and deep.



float
Sharpness

This allows you to push the color toward the shallow or deep end.



float
Scale

The scale of the depth.



void
ExportTexture

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




SgtPlanetWaterTexture

This component can be added alongside the SgtPlanet component to give it an animated water surface texture.


Texture
BaseTexture

The generated water texture will be based on this texture.

NOTE  This should be a normal map.


float
Strength

The strength of the normal map.



float
Speed

The speed of the water animation.




SgtProminence

This component allows you to render a halo disc around a star.


Texture
MainTex

The main texture of the prominence.



Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the prominence material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



int
Seed

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



int
PlaneCount

The amount of planes used to build the prominence.



int
PlaneDetail

The amount of quads used to build each plane.



float
RadiusMin

The inner radius of the prominence planes in local coordinates.



float
RadiusMax

The outer radius of the prominence planes in local coordinates.



bool
FadeEdge

Should the plane fade out when it's viewed edge-on?



float
FadePower

How sharp the transition between visible and invisible is.



bool
ClipNear

Should the plane fade out when it's in front of the star?



float
ClipPower

How sharp the transition between visible and invisible is.



float
CameraOffset

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



bool
Distort

Should the prominence be animated to distort? This makes the edges flicker like a flame.



Texture
DistortTex

This allows you to set the distortion texture that gets repeated on the prominence surface.



float
DistortScaleX

The distortion texture horizontal tiling.



int
DistortScaleY

The distortion texture vertical tiling.



float
DistortStrength

The distortion texture strength.



Vector2
DistortOffset

The UV offset of the distortion texture.



Vector2
DistortSpeed

The scroll speed of the distortion texture UV offset.



bool
Detail

Should the disc have a detail texture? For example, dust noise when you get close.



Texture
DetailTex

This allows you to set the detail texture that gets repeated on the prominence surface.



float
DetailScaleX

The detail texture horizontal tiling.



int
DetailScaleY

The detail texture vertical tiling.



float
DetailStrength

The detail texture strength.



Vector2
DetailOffset

The UV offset of the detail texture.



Vector2
DetailSpeed

The scroll speed of the detail texture UV offset.




SgtRing

This component allows you to render a planetary ring. This ring can be split into multiple segments to improve depth sorting.


Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
Rayleigh

This allows you to adjust the render queue of the ring material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



Texture2D
MainTex

The texture applied to the ring, where the left side is the inside, and the right side is the outside.



Mesh
Mesh

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



float
Occlusion

This allows you to specify how much light this ring can block from light flares.



int
Segments

This allows you to set how many copies of the Mesh are required to complete the ring. For example, if the Mesh is 1/4 of the ring, then Segments should be set to 4.



bool
Detail

Should the ring have a detail texture? For example, dust noise when you get close.



Texture
DetailTex

This allows you to set the detail texture that gets repeated on the ring surface.



float
DetailScaleX

The detail texture horizontal tiling.



int
DetailScaleY

The detail texture vertical tiling.



Vector2
DetailOffset

The UV offset of the detail texture.



Vector2
DetailSpeed

The scroll speed of the detail texture UV offset.



float
DetailTwist

The amount the detail texture is twisted around the ring.



float
DetailTwistBias

The amount the twisting is pushed to the outer edge.



bool
Near

Enable this if you want the ring to fade out as the camera approaches.



Texture
NearTex

The lookup table used to calculate the fade opacity based on distance, where the left side is used when the camera is close, and the right side is used when the camera is far.



float
NearDistance

The distance the fading begins from in world space.



bool
Scattering

If you enable this then light will scatter through the ring atmosphere. This means light entering the eye will come from all angles, especially around the light point.



float
ScatteringMie

The mie scattering term, allowing you to adjust the distribution of front scattered light.



float
ScatteringStrength

The scattering is multiplied by this value, allowing you to easily adjust the brightness of the effect.



bool
Lit

If you enable this then nearby SgtLight and SgtShadow casters will be found and applied to the lighting calculations.



Texture
LightingTex

The look up table associating light angle with surface color. The left side is used on the dark side, the middle is used on the horizon, and the right side is used on the light side.



Color
AmbientColor

The ring will always be lit by this amount.




SgtRingLightingTex

This component allows you to generate the SgtRing.LightingTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



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 SgtRing component's LightingTex setting using the exported asset.




SgtRingMainTexFilter

This component allows you to generate the SgtRing.MainTex field based on a simple RGB texture of a ring.


Texture2D
Source

The source ring texture that will be filtered.



TextureFormat
Format

The format of the generated texture.



float
Power

The sharpness of the light/dark transition.



float
Exposure

This allows you to control the brightness.



void
ExportTexture

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

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




SgtRingMesh

This component allows you to generate the SgtRing.Mesh field.


int
Segments

The amount of segments the final ring will be comprised of.



int
SegmentDetail

The amount of triangle edges along the inner and outer edges of each segment.



float
RadiusMin

The radius of the inner edge in local space.



float
RadiusMax

The radius of the outer edge in local space.



int
RadiusDetail

The amount of edge loops around the generated ring. If you have a very large ring then you can end up with very skinny triangles, so increasing this can give them a better shape.



float
BoundsShift

The amount the mesh bounds should get pushed out by in local space. This should be used with 8+ Segments.



SgtShadowRing
Shadow

If you want these values to control the shadow RadiusMin/Max, then set this here.



void
ExportOuterTexture

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

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




SgtRingNearTex

This component allows you to generate the SgtRing.NearTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



SgtEase.Type
Ease

The ease type used for the transition.



float
Sharpness

The sharpness of the 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 SgtRing component's NearTex setting using the exported asset.




SgtCamera

This component monitors the attached Camera for modifications in roll angle, and stores the total change.


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.




SgtCameraState

This class can be used to easily save & load the state of an object (e.g. transform position) based on the camera rendering state.


Camera
Camera

The camera associated with this state.




SgtDelay

This class allows you to execute an event at a later point in the game loop.



SgtDepthTextureMode

This component allows you to control a Camera component's depthTextureMode setting.


DepthTextureMode
DepthMode

The depth mode that will be applied to the camera.




SgtEase

This class handles ease types used for various SGT features like atmosphere color falloff.



SgtEditor

This is the base class for all inspectors.



SgtGuide

This class defines documentation data that can be viewed in the inspector.



SgtHelper

This class contains some useful features used by most other SGT code.


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.




SgtHelper

This class contains some useful editor-only features used by most other SGT code.



SgtLight

This component marks the attached Light as one that will be used by SGT. Most SGT features only work with a limited amount of lights, so having to explicitly define which ones will be used helps stop you going over this limit.


bool
TreatAsPoint

The SgtLightPointer component allows you to treat a Directional light like a Point light, and enabling this allows you to notify SGT about this.



float
Multiplier

All light values will be multiplied by this before use.



float
IntensityInSGT

This allows you to control the intensity of the this light when used by SGT components that implement their own custom lighting (e.g. SgtAtmosphere). This should typically be in the 0..1 range.



float
IntensityInStandard

This allows you to control the intensity of the attached light when using the Standard rendering pipeline.

-1 = The attached light intensity will not be modified.



float
IntensityInURP

This allows you to control the intensity of the attached light when using the URP rendering pipeline.

-1 = The attached light intensity will not be modified.



float
IntensityInHDRP

This allows you to control the intensity of the attached light when using the HDRP rendering pipeline.

-1 = The attached light intensity will not be modified.




SgtLightOverride

This component allows you to override the attached Light.intensity value based on the rendering pipeline.



SgtLightPointer

This component points the current light toward the rendering camera, giving you the illusion that it's a point light. This is useful for distant lights that you want to cast shadows.



SgtLinkedBehaviour<T>

This class allows for quick registering and unregistering of class instances that can then be quickly looped through



SgtLong3

This implements Vector3 using the long data type.



SgtLongBounds

This implements Bounds using the long data type.



SgtLongRect

This implements a Rect using the long data type.



SgtOcclusion

This class allows you to calculate how much light is occluded between two 3D points.


static float
Calculate
int layers, Vector4 eye, Vector4 tgt

This method performs the calculations. The eye and tgt arguments store the position in .xyz, and the radius in .w, both in world space.




SgtOcclusionScaler

This component scales the current GameObject based on optical thickness between the current camera and the current position.

This is done using the SgtOcclusion.Calculate method, which works using Physics.Raycast, and custom occlusion checks.

You can add your own custom occlusion checks by hooking into the SgtHelper.OnCalculateOcclusion event.


LayerMask
Layers

The layers that will be sampled when calculating the occlusion.



Vector3
MaxScale

This allows you to set the maximum scale when there is no depth.



float
Radius

This allows you to set the radius of the object that will be scaled (e.g. light flare). This changes how it get occluded by objects that pass in front.




SgtPoolClass<T>

This class can be used to pool normal C# classes.



SgtPoolComponent

This component is automatically generated by SGT components that implement GameObject pooling (e.g. SgtTerrainFace).


string
TypeName

The name of the type this pool manages.



List<Component>
Elements

The pooled elements in this pool.




SgtPoolObject

This component is automatically generated by SGT components that implement Object pooling (e.g. Mesh).


string
TypeName

The name of the type this pool manages.



List<Object>
Elements

The pooled elements in this pool.




SgtProcedural

This component is the basis for all procedural components in SGT.


GenerateType
Generate

This allows you to control when this component will be generated.



int
Seed

The seed used for automatic generation.



void
GenerateWith
int seed

This method allows you to manually generate this component with the specified seed.




SgtProperties

This class wraps MaterialPropertyBlock to allow for the removal of specific properties.



SgtQuads

This is the base class for all starfields, providing a simple interface for generating meshes from a list of stars, as well as the material to render it.


Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



Texture
MainTex

The main texture of this material.



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.



BlendModeType
BlendMode

The blend mode used to render the material.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the quads material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.




SgtRenderQueue

This allows you to specify the render queue for a material.



SgtSeedAttribute

This attribute allows you to turn a normal integer into a seed integer, adding a button to its inspector, allowing you to quickly randomize it.



SgtShader

This class caches all shader property IDs used by SGT shaders.



SgtShadow

This base class handles calculation of a shadow matrix and shadow texture.



SgtShadowLayer

This component allows you to add shadows cast from an SgtShadow___ component to any opaque renderer in your scene.


float
Radius

The radius of this shadow receiver.



List<MeshRenderer>
Renderers

The renderers you want the shadows to be applied to.




SgtShadowRing

This component allows you to cast a ring shadow from the current GameObject.


Texture
Texture

The texture of the shadow (left = inside, right = outside).



float
RadiusMin

The inner radius of the ring casting this shadow (auto set if Ring is set).



float
RadiusMax

The outer radius of the ring casting this shadow (auto set if Ring is set).




SgtShadowRingFilter

This component allows you to generate a blurred SgtShadowRing.Texture based on a normal texture.


Texture2D
Source

The source ring texture that will be filtered.



TextureFormat
Format

The format of the generated texture.



int
Iterations

The amount of blur iterations.



bool
ShareRGB

Overwrite the RGB channels with the alpha?



bool
Invert

Invert the alpha channel?



void
ExportTexture

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

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




SgtShadowSphere

This component allows you to cast a sphere shadow from the current GameObject.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



float
SharpnessR

The sharpness of the sunset red channel transition.



float
SharpnessG

The power of the sunset green channel transition.



float
SharpnessB

The power of the sunset blue channel transition.



float
Opacity

The opacity of the shadow.



float
RadiusMin

The inner radius of the sphere in local space.



float
RadiusMax

The outer radius of the sphere in local space.




SgtShape

This is the base class for all volumetric shapes. These can be used to define regions where effects are visible.


float
GetDensity
Vector3 worldPoint

Returns a 0..1 value, where 1 is fully inside




SgtShapeBox

This component allows you to define a box shape that can be used by other components to perform actions confined to the volume.


Vector3
Extents

The min/max size of the box.



SgtEase.Type
Ease

The transtion style between minimum and maximum density.



float
Sharpness

How quickly the density increases when inside the sphere.




SgtShapeGroup

This component allows you to group multiple SgtShape___ components and treat them as a single large volume.


List<SgtShape>
Shapes

The shapes associated with this group.




SgtShapeSphere

This component allows you to define a sphere shape that can be used by other components to perform actions confined to the volume.


float
Radius

The radius of this sphere in local space.



float
Height

If this is set, then any point within Radius will have maximum density, and it will fall off to zero within the height range.



SgtEase.Type
Ease

The transition style between minimum and maximum density.



float
Sharpness

How quickly the density increases when inside the sphere.




SgtShapeTorus

This component allows you to define a torus shape that can be used by other components to perform actions confined to the volume.


float
Radius

The radius of this torus in local coordinates.



float
Thickness

The radial thickness of the torus in local space.



SgtEase.Type
Ease

The transtion style between minimum and maximum density.



float
Sharpness

How quickly the density increases when inside the torus.




SgtSharedMaterial

This component stores a Material and a list of Renderers, and maintains that all renderers use the material as long as they are all part of this component.


Material
Material

The material that will be applied to all renderers.




SgtBlackHole

This component allows you to render a singularity/black hole.


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.




SgtLens

This component allows you to add a gravitational lensing effect to your scene, as seen around black holes, and other dense bodies.

The lens effect works similar to reflection probes, and uses a cubemap as a source for the texture data.

This means it renders very fast, works consistently across the screen, and can simulate lensing in any direction.

NOTE  Updating the cubemap texture can be expensive, and the effect won't work so well if you have rendered objects to the lens center.

Mesh
Mesh

The mesh used to render the lens effect. This should be a sphere.



int
Resolution

This allows you to set the width & height of each face in the cubemap this component renders.

NOTE  The higher you set this, the higher the visual quality, but the more expensive the texture updates will be.


float
Range

This allows you to set the world space distance where the specified resolution will be used. Each time the distance doubles, the resolution will be halved.

0 = Ignore distance, and use a fixed resolution.



float
Interval

This allows you to control how often the cubemap texture updates in seconds.

-1 = Manual only.

0 = Every frame.

2 = Every two seconds.



float
FadeOuter

This allows you to control how the edge of the effect fades away into the normal scene. There will usually be some difference between the actual scene and the spatially distorted scene rendered from the cubemap, and this can hide that transition.



float
WarpOuter

This allows you control how far from the outer edge the spatial distortion begins.



float
WarpStrength

This allows you control the strength of the spatial distortion at the event horizon. Higher values will cause the light to bend around, allowing you to see backwards.



float
HoleSize

This allows you to set the size of the black hole disc.



float
HoleEdge

This allows you to control the thickness of the black hole disc (event horizon).



Camera
CachedCamera

This property gives you the Camera alongside this component.



static Material
CachedMaterial

This property gives you the Material used by this component when rendering




SgtSpacetime

This component allows you to render a grid that can be deformed by SgtSpacetimeWell components.


Vector2
Center

The center of the spacetime grid in local space.



Vector2
Size

The size of the spacetime grid in local space.



Mesh
Mesh

The mesh used to render the spacetime.



Color
Color

The base color will be multiplied by this.



float
Brightness

The Color.rgb values are multiplied by this, allowing you to quickly adjust the overall brightness.



SgtRenderQueue
RenderQueue

This allows you to adjust the render queue of the spacetime material. You can normally adjust the render queue in the material settings, but since this material is procedurally generated your changes will be lost.



Texture2D
MainTex

The main texture applied to the spacetime.



int
Tile

How many times should the spacetime texture be tiled?



Color
AmbientColor

The ambient color.



float
AmbientBrightness

The ambient brightness.



Color
DisplacementColor

The displacement color.



float
DisplacementBrightness

The displacement brightness.



Color
HighlightColor

The color of the highlight.



float
HighlightBrightness

The brightness of the highlight.



float
HighlightScale

The scale of the highlight.



float
HighlightPower

The sharpness of the highlight.



DisplacementType
Displacement

How should the vertices in the spacetime get displaced when a well is nearby?



bool
Accumulate

Should the displacement effect additively stack if wells overlap?



float
Power

The pinch power.



Vector3
Offset

The offset direction/vector for vertices within range of a well.



bool
RequireSameLayer

Filter all the wells to require the same layer at this GameObject.



bool
RequireSameTag

Filter all the wells to require the same tag at this GameObject.



string
RequireNameContains

Filter all the wells to require a name that contains this.




SgtSpacetimeGrid

This component allows you to generate the SgtSpacetime component's Mesh setting.


int
CellsX

The amount of cells along the X axis.



int
CellsZ

The amount of cells along the Z axis.




SgtSpacetimeMesh

This component allows you to generate the SgtSpacetime component's Mesh setting.


int
QuadsX

The amount of quads along the X axis.



int
QuadsZ

The amount of quads along the Z axis.



void
ExportMesh

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

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




SgtSpacetimeModifier

This component allows you to generate the SgtSpacetime component's Mesh setting.



SgtSpacetimeWell

This component allows you to deform SgtSpacetime grids.


DistributionType
Distribution

The method used to deform the spacetime.



float
Radius

The radius of this spacetime well.



float
Frequency

The frequency of the ripple.



float
Strength

The minimum strength of the well.



float
Offset

The frequency offset.



float
OffsetSpeed

The frequency offset speed per second.



float
HoleSize

The size of the twist hole.



float
HolePower

The power of the twist hole.




SgtStarfield

This is the base class for all starfields that store star corner vertices the same point/location and are stretched out in the vertex shader, allowing billboarding in view space, and dynamic resizing.


bool
PowerRgb

Instead of just tinting the stars with the colors, should the RGB values be raised to the power of the color?



bool
ClampSize

Prevent the quads from being too small on screen?



float
ClampSizeMin

The minimum size each star can be on screen in pixels. If the star goes below this size, it loses opacity proportional to the amount it would have gone under.



bool
Stretch

Should the stars stretch if an observer moves?



Vector3
StretchVector

The vector of the stretching.



float
StretchScale

The scale of the stretching relative to the velocity.



float
StretchLimit

When warping with the floating origin system the camera velocity can get too large, this allows you to limit it.



bool
Near

Should the stars fade out when the camera gets near?



Texture
NearTex

The lookup table used to calculate the fading amount based on the distance.



float
NearThickness

The thickness of the fading effect in world space.



bool
Pulse

Should the stars pulse in size over time?



float
PulseOffset

The amount of seconds this starfield has been animating.



float
PulseSpeed

The animation speed of this starfield.




SgtStarfieldBox

This component allows you to render a starfield with a distribution of a box.


int
Seed

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



Vector3
Extents

The +- size of the starfield.



float
Offset

How far from the center the distribution begins.



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
StarPulseMax

The maximum amount a star's size can pulse over time. A value of 1 means the star can potentially pulse between its maximum size, and 0.




SgtStarfieldCustom

This component allows you to specify the exact position/size/etc of each star in this starfield.


List<SgtStarfieldStar>
Stars

The stars that will be rendered by this starfield.

NOTE  If you modify this then you must then call the DirtyMesh method.



SgtStarfieldDome

This component allows you to render a starfield with a dome like distribution.


int
Seed

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



float
Radius

The radius of the starfield.



float
Bias

This allows you to control if the stars should cluster near the horizon, or near the azimuth.



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
StarPulseMax

The maximum amount a star's size can pulse over time. A value of 1 means the star can potentially pulse between its maximum size, and 0.




SgtStarfieldElliptical

This component allows you to render a starfield with a distribution like an elliptical galaxy.


int
Seed

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



float
Radius

The radius of the starfield.



float
Symmetry

Should more stars be placed near the horizon?



float
Offset

How far from the center the distribution begins.



float
Bias

Invert the distribution?



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
StarPulseMax

The maximum amount a star's size can pulse over time. A value of 1 means the star can potentially pulse between its maximum size, and 0.




SgtStarfieldInfinite

This component allows you to render a starfield that repeats forever.


float
Softness

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



bool
Far

Should the stars fade out when the camera gets too far away?



Texture
FarTex

The lookup table used to calculate the fading amount based on the distance.



float
FarRadius

The radius of the fading effect in world coordinates.



float
FarThickness

The thickness of the fading effect in world coordinates.



int
Seed

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



Vector3
Size

The size of the starfield in local space.



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
StarPulseMax

The maximum amount a star's size can pulse over time. A value of 1 means the star can potentially pulse between its maximum size, and 0.




SgtStarfieldInfiniteFarTex

This component allows you to generate the SgtStarfieldInfinite.FarTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The format of the generated texture.



SgtEase.Type
Ease

The transition style.



float
Sharpness

The sharpness of the 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 SgtStarfieldInfinite component's FarTex setting using the exported asset.




SgtStarfieldNearTex

This component allows you to generate the SgtStarfield.NearTex field.


int
Width

The width of the generated texture. A higher value can result in a smoother transition.



TextureFormat
Format

The texture format of the generated texture.



SgtEase.Type
Ease

The transition style.



float
Sharpness

The sharpness of the transition.



float
Offset

The start point of the fading.



void
ExportTexture

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

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




SgtStarfieldNebula

This component allows you to render a nebula as a starfield from a single pixture.


int
Seed

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



Texture
SourceTex

This texture used to color the nebula particles.



float
Threshold

This brightness of the sampled SourceTex pixel for a particle to be spawned.



int
Samples

The amount of times a nebula point is randomly sampled, before the brightest sample is used.



float
Jitter

This allows you to randomly offset each nebula particle position.



SourceType
HeightSource

The calculation used to find the height offset of a particle in the nebula.



SourceType
ScaleSource

The calculation used to find the scale modified of each particle in the nebula.



Vector3
Size

The size of the generated nebula.



float
HorizontalBrightness

The brightness of the nebula when viewed from the side (good for galaxies).



float
HorizontalPower

The relationship between the Brightness and HorizontalBrightness relative to the viewing angle.



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
StarTint

This allows you to control how much the underlying nebula pixel color influences the generated star color.

0 = StarColors gradient will be used directly.

1 = Colors will be multiplied together.



float
StarBoost

Should the star color luminosity be boosted?



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
StarPulseMax

The maximum amount a star's size can pulse over time. A value of 1 means the star can potentially pulse between its maximum size, and 0.




SgtStarfieldSpiral

This component allows you to generate a starfield in a spiral pattern.


int
Seed

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



float
Radius

The radius of the starfield.



int
ArmCount

The amount of spiral arms.



float
Twist

The amound each arm twists.



float
ThicknessInner

This allows you to set the thickness of the star distribution at the center of the spiral.



float
ThicknessOuter

This allows you to set the thickness of the star distribution at the edge of the spiral.



float
ThicknessPower

This allows you to push stars away from the spiral, giving you a smoother distribution.



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
StarPulseMax

The maximum amount a star's size can pulse over time. A value of 1 means the star can potentially pulse between its maximum size, and 0.




SgtStarfieldStar

This class stores information about a single star inside a starfield. These can either be manually populdated using a custom starfield, or they're procedurally generated.


int
Variant

The coordinate index in the asteroid texture.



Color
Color

Color tint of this star.



float
Radius

Radius of this star in local space.



float
Angle

Angle in degrees.



Vector3
Position

Local position of this star relative to the starfield.



float
PulseSpeed

How fast this star pulses (requires AllowPulse).



float
PulseRange

How much this star can pulse in size (requires AllowPulse).



float
PulseOffset

The original pulse offset (requires AllowPulse).




SgtThruster

This component allows you to create simple thrusters that can apply forces to Rigidbodies based on their position. You can also use sprites to change the graphics.


float
Throttle

How active is this thruster? 0 for off, 1 for max power, -1 for max reverse, etc.



Rigidbody
Body

The rigidbody you want to apply the thruster forces to



bool
ForceAtPosition

The type of force we want to apply to the Rigidbody.



ForceMode
ForceMode

The force mode used when ading force to the Rigidbody.



float
ForceMagnitude

The maximum amount of force applied to the rigidbody (when the throttle is -1 or 1).



static SgtThruster
Create
int layer = 0, Transform parent = null

Create a child GameObject with a thruster attached




SgtThrusterRoll

This component allows you to create simple thrusters that can apply forces to Rigidbodies based on their position. You can also use sprites to change the graphics


Vector3
Rotation

The rotation offset in degrees.




SgtThrusterScale

This component allows you to create simple thrusters that can apply forces to Rigidbodies based on their position. You can also use sprites to change the graphics


SgtThruster
Thruster

The thruster the scale will be based on.



float
Damping

The speed at which the scale reaches its target value.



Vector3
BaseScale

The scale value that's applied by default.



Vector3
ThrottleScale

The scale value that's added when the throttle is 1.



float
Flicker

The amount the ThrottleScale flickers over time.



float
FlickerOffset

The offset of the flicker animation.



float
FlickerSpeed

The speed of the flicker animation.




SgtFloatingCamera

This component marks the current GameObject as a camera. This means as soon as the transform.position strays too far from the origin (0,0,0), it will snap back to the origin.

After it snaps back, the SnappedPoint field will be updated with the current position of the SgtFloatingOrigin 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.

NOTE  This requires you to use the SgtFloatingOrigin component.


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 localPosition

This gives you the universal SgtPosition of the input camera-relative world space position.



Vector3
CalculatePosition
SgtPosition input

This gives you the camera-relative position of the input SgtPosition in world space.



Vector3
CalculatePosition
ref SgtPosition input

This gives you the camera-relative position of the input SgtPosition in world space.



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.




SgtFloatingFollow

This component makes the current SgtPoint follow the Target SgtPoint.

This is useful because you can't parent/child SgtPoint components like SgtFloatingCamera and SgtFloatingObject.


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.




SgtFloatingLight

This component will rotate the current GameObject toward the SgtFloatingOrigin point. This makes directional lights compatible with the floating origin system.



SgtFloatingLod

This component allows you to spawn a prefab as a child of the current GameObject when the floating camera gets within the specified range.


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.




SgtFloatingObject

This component turns a normal GameObject + Transform into one that works with the floating origin system.

Keep in mind the Transform.position value will be altered based on camera movement, so certain components may not work correctly without modification.

For example, if you make this Transform.position between two positions, then those positions will be incorrect when the floating origin snaps to a new position.

To correctly handle this scenario, you must hook into the either this component's OnSnap event, or the static SgtFloatingCamera.OnPositionChanged event, and offset your position values from the given Vector3 delta.


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.

NOTE  This should only be called from an SgtFloatingSpawner___ component.



SgtFloatingOrbit

This component will orbit the attached SgtFloatingPoint around the parent SgtFloatingPoint.


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.




SgtFloatingOrbitVisual

This component draws an orbit in 3D space.


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.




SgtFloatingParticleSystem

This component updates the position of the attached ParticleSystem component when the floating origin system snaps.



SgtFloatingPoint

This component wraps SgtPosition into a component, and defines a single point in the floating origin system.

Normal transform position coordinates are stored using floats (Vector3), but SgtPosition coordinates are stored using a long and a double pair.

The long is used to specify the current grid cell, and the double is used to specify the high precision relative offset to the grid cell.

Combined, these values allow simulation of the whole observable universe.


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
PositionChanged

Call this method after you've finished modifying the Position, and it will notify all event listeners.



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.




SgtFloatingRigidbody

This component should modify SgtFloatingObject to work with Rigidbodies that have interpolation to eliminate stuttering from origin shifts. But for some reason it doesn't do anything?



SgtFloatingRoot

All prefabs spawned from SgtFloatingLod and SgtFloatingSpawner___ will be attached to this GameObject.



SgtFloatingScaler

This component scales the current SgtFloatingObject based on its distance to the SgtFloatingOrigin.

This scaling allows you to see the object from a greater distance than usual, which is very useful for star/planet/etc billboards you need to see from a distance.


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.




SgtFloatingSpawner

This is the base class for all floating origin spawners, providing a useful methods for spawning and handling prefabs.


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.




SgtFloatingSpawnerOrbit

This component will automatically spawn prefabs in orbit around the attached SgtFloatingPoint.


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.




SgtFloatingSpawnerRing

This component will automatically spawn prefabs in a ring around the attached SgtFloatingPoint.


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.




SgtFloatingSpawnerSphere

This component will automatically spawn prefabs in a circle around the attached SgtFloatingPoint.


int
Count

The amount of prefabs that will be spawned.



SgtLength
Radius

The maximum distance away the prefabs can spawn in meters.



float
Offset

The higher this value, the more likely the spawned objects will be pushed to the edge of the radius.



float
VelocityScale

This allows you to set how much orbital velocity the spawned objects get if they have a Rigidbody attached.




SgtFloatingSpeedometer

This component monitors the specified SgtFloatingCamera or SgtFloatingObject point for position changes, and outputs the speed of those changes to the OnString event.


SgtFloatingPoint
Point

The point whose speed will be monitored.



string
Format

The format of the speed text.



UpdateType
UpdateIn

This allows you to control where in the game loop the speed will be calculated.



StringEvent
OnString

Each time the speed updates this event will fire, which you can link to update UI text.




SgtFloatingTarget

This component marks the attached LeanFloatingPoint component as a warpable target point. This allows you to pick the target using the SgtWarpPin component.


string
WarpName

The shorthand name for this warp target.



SgtLength
WarpDistance

The distance from this SgtFloatingPoint we should warp to, to prevent you warping too close.




SgtFloatingWarp

This is the base class for all warp styles.


SgtFloatingPoint
Point

The point that will be warped.



void
WarpTo
SgtFloatingTarget target

Allows you to warp to the target object.



void
WarpTo
SgtPosition position, double distance

Allows you to warp to the target point with the specified separation distance.




SgtFloatingWarpButton

This component allows you to warp to the target when clicking a button.

NOTE  The button's OnClick event must be linked to the Click method.

SgtFloatingTarget
Target

The point that will be warped to.



SgtFloatingWarp
Warp

The warp effect that will be used.




SgtFloatingWarpPin

This component moves Rect above the currently picked SgtFloatingTarget. You can tap/click the screen to update the picked target.


LayerMask
GuiLayers

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



float
PickDistance

The maximum distance between the tap/click point at the SgtWarpTarget in scaled screen space.



SgtFloatingTarget
CurrentTarget

The currently picked target.



RectTransform
Parent

The parent rect of the pin.



RectTransform
Rect

The main rect of the pin that will be placed on the screen on top of the CurrentTarget.



Text
Title

The name of the pin.



CanvasGroup
Group

The group that will control hide/show of the pin.



SgtFloatingWarp
Warp

The warp component that will be used.



bool
HideIfTooClose

Hide the pin if we're within warping distance?




SgtFloatingWarpSmoothstep

This component will smoothly warp to the target, where the speed will slow down near the start of the travel, and near the end.


double
WarpTime

Seconds it takes to complete a warp.



int
Smoothness

Warp smoothstep iterations.



bool
Warping

Currently warping?



double
Progress

Current warp progress in seconds.



SgtPosition
StartPosition

Start position of the warp.



SgtPosition
TargetPosition

Target position of the warp.




SgtLength

This struct allows you to define a length or distance in the floating origin system. Using one value can be difficult to visualize, so the specified value is multiplied by the specified galactic scale (e.g. AU), allowing you to more easily specify large distances.



SgtPosition

This class stores a coordinate in the floating origin system, and provides methods to manipulate them.


static readonly double
CELL_SIZE

When the LocalX/Y/Z values exceed this value, the Global/X/Y/Z values will be modified to account for it, creating a grid system

The universe is 4.4e+26~ meters in radius

A long stores up to +- 9.2e+18~

Divide them, and you get 47696652.0723

Thus the below value allows you to simulate a universe that is larger than the current observable universe



double
LocalX

The position in meters along the X axis, relative to the current global cell position.



double
LocalY

The position in meters along the Y axis, relative to the current global cell position.



double
LocalZ

The position in meters along the Z axis, relative to the current global cell position.



long
GlobalX

The current grid cell along the X axis. Each grid cell is equal to 50000000 meters.



long
GlobalY

The current grid cell along the Y axis. Each grid cell is equal to 50000000 meters.



long
GlobalZ

The current grid cell along the Z axis. Each grid cell is equal to 50000000 meters.




SgtSpawnList

This component allows you to create a list of SgtFloatingObject prefabs that are associated with a specific Category name.

This allows you to easily manage what objects get spawned from each type of spawner.


string
Category

The type of prefabs these are (e.g. Planet).



List<SgtFloatingObject>
Prefabs

The prefabs beloning to this spawn list.




Index

Thank you for using Space Graphics Toolkit ❤️

Required Packages

How do I upgrade?

Where do I get more packs?

Why does each feature require so many components?

How do I use this from C#?

Which versions of Unity are supported?

Is URP/HDRP supported?

Is VR supported?

Does this work on mobile/console/WebGL/etc?

Known Issues

Accretion

Atmosphere

Aurora

Backdrop

Belt

Billboard

Cloudsphere

Corona

Debris

Flare

Jovian

Lightning

Planet

Prominence

Ring

Singularity

Spacetime

Star

Starfield

Terrain

Thruster

Universe



Assets

Lean GUI

Lean Transition

Paint in 3D

Lean Pool

Space Graphics Toolkit

Lean Touch

Lean Localization

Lean GUI Shapes

Destructible 2D

Planet Pack - Space Graphics Toolkit

Lean Touch+

Volumetric Audio



Versions

3.8.4

3.8.3

3.8.2

3.8.1

3.8.0

3.7.11

3.7.10

3.7.9

3.7.8

3.7.7

3.7.6

3.7.5

3.7.4

3.7.3

3.7.2

3.7.1

3.7.0

3.6.9

3.6.8

3.6.7

3.6.6

3.6.5

3.6.4

3.6.3

3.6.2



Components

SgtAccretion

SgtAccretionMesh

SgtAccretionNearTex

SgtAtmosphere

SgtAtmosphereDepthTex

SgtAtmosphereHeight

SgtAtmosphereLightingTex

SgtAtmosphereScatteringTex

SgtAurora

SgtAuroraMainTex

SgtAuroraNearTex

SgtBackdrop

SgtBackdropQuad

SgtBelt

SgtBeltAsteroid

SgtBeltCustom

SgtBeltLightingTex

SgtBeltSimple

SgtBillboard

SgtFastBillboard

SgtFastBillboardManager

SgtCloudsphere

SgtCloudsphereDepthTex

SgtCloudsphereLightingTex

SgtCloudsphereNearTex

SgtCorona

SgtCoronaDepthTex

SgtDebris

SgtDebrisGrid

SgtDebrisSpawner

SgtFlare

SgtFlareMaterial

SgtFlareMesh

SgtJovian

SgtJovianDepthTex

SgtJovianLightingTex

SgtJovianScatteringTex

SgtLightning

SgtLightningSpawner

SgtPlanet

SgtPlanetWaterGradient

SgtPlanetWaterTexture

SgtProminence

SgtRing

SgtRingLightingTex

SgtRingMainTexFilter

SgtRingMesh

SgtRingNearTex

SgtCamera

SgtCameraState

SgtDelay

SgtDepthTextureMode

SgtEase

SgtEditor

SgtGuide

SgtHelper

SgtHelper

SgtLight

SgtLightOverride

SgtLightPointer

SgtLinkedBehaviour<T>

SgtLong3

SgtLongBounds

SgtLongRect

SgtOcclusion

SgtOcclusionScaler

SgtPoolClass<T>

SgtPoolComponent

SgtPoolObject

SgtProcedural

SgtProperties

SgtQuads

SgtRenderQueue

SgtSeedAttribute

SgtShader

SgtShadow

SgtShadowLayer

SgtShadowRing

SgtShadowRingFilter

SgtShadowSphere

SgtShape

SgtShapeBox

SgtShapeGroup

SgtShapeSphere

SgtShapeTorus

SgtSharedMaterial

SgtBlackHole

SgtLens

SgtSpacetime

SgtSpacetimeGrid

SgtSpacetimeMesh

SgtSpacetimeModifier

SgtSpacetimeWell

SgtStarfield

SgtStarfieldBox

SgtStarfieldCustom

SgtStarfieldDome

SgtStarfieldElliptical

SgtStarfieldInfinite

SgtStarfieldInfiniteFarTex

SgtStarfieldNearTex

SgtStarfieldNebula

SgtStarfieldSpiral

SgtStarfieldStar

SgtThruster

SgtThrusterRoll

SgtThrusterScale

SgtFloatingCamera

SgtFloatingFollow

SgtFloatingLight

SgtFloatingLod

SgtFloatingObject

SgtFloatingOrbit

SgtFloatingOrbitVisual

SgtFloatingParticleSystem

SgtFloatingPoint

SgtFloatingRigidbody

SgtFloatingRoot

SgtFloatingScaler

SgtFloatingSpawner

SgtFloatingSpawnerOrbit

SgtFloatingSpawnerRing

SgtFloatingSpawnerSphere

SgtFloatingSpeedometer

SgtFloatingTarget

SgtFloatingWarp

SgtFloatingWarpButton

SgtFloatingWarpPin

SgtFloatingWarpSmoothstep

SgtLength

SgtPosition

SgtSpawnList