Space Graphics Toolkit

Thank you for using Space Graphics Toolkit ❤️

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

If you have any questions, then feel free to send me an E-Mail, or Private Message.

You can also ask in the Forum Thread.

You can also check the YouTube Channel.

I'm also available for freelance work if you need help with your projects.



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.



What is Space Graphics Toolkit?

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.



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 1

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.

The biggest difference is that editing an inspector setting will automatically update the component state, whereas doing this from code won't. This is because the settings are fields, and so the component doesn't know the value changed.

It would be possible to automatically update the components using a property, but I didn't want to introduce performance issues if you need to update many settings at the same time, or increase complexity of the code using some kind of dirty marking system.

Therefore, to change component settings and update them, you can either:

Method 1 Call the SetXXX method that automatically updates the component state. For example, the SgtAtmosphere component has the SetColor method, which can be used instead of setting the Color field directly. Keep in mind that this instantly updates the component, so you shouldn't use multiple Set methods in a row.
Method 2 Call the UpdateXXX method after you update the fields. For example, the SgtAtmosphere has the UpdateMaterials method, which you can call after updating fields that depend on the material state. To find which Update method you need to call to update a specific field, you can look at the inspector code at the top of the source file for the component, or see the Set method code associated with the field.


Are scriptable render pipelines (SRP) supported?

LWRP/URP is fully supported, and HDRP is mostly supported (currently being worked on).

After you've enabled a scriptable rendering pipeline in your Graphics settings:

STEP 1  Go to to the Space Graphics Toolkit > Features > Shared > Resources folder.
STEP 2  Select the SgtRenderingPipeline asset.
STEP 3  Click the Switch To Scriptable Pipeline button.
DONE  SGT has now been converted to use SRP.

If you decide to go back to the standard rendering pipeline, then you can click the Switch To Standard Pipeline button.

NOTE: If you want to use LWRP/URP with the SgtSingulairty feature (black holes), then you must enable the Opaque Texture setting in your pipeline settings asset.


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 compatibility in mind, and have been heavily optimized to run on almost any device and platform, while still giving impressive visual results.

The only heavy feature that should be used with care is SgtTerrain (dynamic planet LOD), because it can require a lot of resources to generate and render. This component has many settings to reduce triangle couunt for lower end decides though.



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 an animated lightning effect to your planet. The lightning is procedurally spawned around the planet, and the animation is defined by the texture, giving you very high performance.

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



Planet

The Planet feature comes with an advanced planet shader. This shader combines standard planet textures (e.g. Albedo + Normal), and greatly enhances them with an advanced detail texturing system, as well as a dynamic water level system.

NOTE: For best results this shader should be used with one of the Geosphere__(Planet) meshes inside the Features/Planet/Examples folder. These meshes contain additional UV data used by this shader to produce seamless detail textures.


Shader Settings

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.

Night Lights

This is the emissive texture for the planet's dark side. 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.

Normal Map

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

Normal Map Scale

This allows you to dampen or strengthen the normal map effect.

Ice (R) Height (A)

This is the additional data map, where the ice mask is stored in the red channel, and the height is stored in the alpha channel.

For now, the AO map is stored in the green channel, and the slope map is stored in the blue channel, but these are currently unused.

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

Detail Map (RGB)

This allows you to control where the detail textures are applied, where the red channel is detail map A, the green channel is detail map B, and

the blue channel is the transition to the planet poles. This should match the albedo mapping.

Detail Tiling

This allows you control the amount of times the detail textures are tiled along the surface.

Detail Map A

This allows you to set the first detail normal map.

Detail Scale A

The allows you to reduce or increase the normal map strength.

Detail Map B

This allows you to set the second detail normal map.

Detail Scale B

The allows you to reduce or increase the normal map strength.

Water

If you enable this then your planet will be given water.

Keep in mind this feature uses the terrain height, you must set the "Ice (R) Height (A)" texture with valid alpha.

Ice Over Water

If you want ice to always appear above water on your planet regardless of water level then you can enable this.

Keep in mind this feature uses the ice map, you must set the "Ice (R) Height (A)" texture with valid red.

Water Tiling

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

Water Level

This allows you to control the water level, where 0 is no water, and 1 is full water. You can set this higher than 1 because water is transparent and a value of 1 may still reveal some land.

Water Color

This allows you set the water color lookup table texture, where the left side is used along the shore, and the right side is used in the deep ocean.

Water Color Scale

This allows you to set how quickly the water color texture goes to the deep ocean color on the right side.

Water Normal Map

This allows you to set the normal used by the water.

Water Normal Scale

The allows you to reduce or increase the normal map strength.

Water Sharpness

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

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.



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 black holes to your scene that simulate light bending from their strong gravitational force.

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



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 includes a star surface shader that renders with procedural animation, giving you full control over its visuals to make any kind of star surface you like.

To make your own, simply make a new Material with the Space Graphics Toolkit/Star shader, and adjust the settings as you like.

NOTE: I recommend you keep the NoiseTex and Noise Step settings as they are.

Feel free to experiment with the other settings to see what visual changes is makes. You can always look at the example star materials to get some ideas.



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 generate a planet or star surface whose mesh dynamically subdivides based on camera proximity. This allows you to make terrains that look good up close, without using too many triangles compared to a static mesh. This feature also comes with components to procedurally spawn objects on the terrain surface, deform the height using noise, and much more.

NOTE: This feature is designed to make high detailed surface meshes with some procedural generation, it's not designed to generate realistic 1:1 scale planets like Earth or even the Moon.


Making a Terrain

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

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

Your scene should now contain a new selected GameObject called Terrain with the SgtTerrain component.

You should then set the SgtTerrain.MaterialSgtTerrain to the material of your choosing.

NOTE: For performance reasons terrains use cube mapped UV data, not equirectangular (cylindrical) projection. So you cannot use the normal materials you put on sphere planets. Follow the Creating Cube Textures documentation to learn how to convert them and use the SgtTerrainCubeMaterials component to assign them.


Adding LOD

By default a terrain won't have any LOD. To add some, you need to fill the SgtTerrain.Distances list.

If you click the Add Distance button, then either a distance of 1 will be added, or half the value of the last distance in the list will be added.

The distance values are are local space, so if your terrain has a scale of 1,1,1, and it is in the root of your Hierarchy, then a distance of 100 means a distance of 100 meters is required for any terrain surfaces with the current LOD level to split into 4 smaller children. These children then use the next LOD distance to calculate if they should split or not.



Adding Height

By default the terrain is just a round sphere. To add height, you can set the SgtTerrain.HeightMap setting.

NOTE: This texture must be marked as readable in the texture import settings.
NOTE: This texture should be use equirectangular (cylindrical) projection.


Spawning Objects

If you want to procedurally spawn objects like trees on your terrain then you can add the SgtTerrainSpawner component.

The SgtTerrainSpawner.Prefabs list can contain any prefab with the SgtTerrainObject component attached. This component is used to manage object pooling, procedural scaling, and other features.

The SgtTerrainSpawner.Depth setting allows you to set which LOD depth you want the objects to appear on. If you set this to 1 then your terrain surface must split at least once for the objects to appear.

The SgtTerrainSpawner.Probability setting is used to procedurally choose if an object is spawned on the current terrain surface if it's on the correct depth. This probability is checked multiple times until it either fails or it reaches the SgtTerrainSpawner.SpawnCountMax setting.

You can also set the SgtTerrainSpawner.HeightMin/Max settings to control the heights that objects can be spawned on. This is in local space and corresponds to the SgtTerrain.Radius setting + any height modifications.



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.

All floating objects in your scene will also snap back based on the snap distance.

NOTE: If you add the SgtFloatingObject component to a GameObject, if it has any parents, make sure none of them also have the SgtFloatingObject component. If they do, they will both snap, compounding the effect for the child. You should keep all floating objects separate.


Handling Snaps

If you need to update a script whenever the camera snaps, you can hook into the SgtFloatingCamera.OnSnap event. This event tells you which camera snapped, and how many world space units it snapped.

You can also hook into the OnSnap event from the SgtFloatingObject component.



High Precision Positions

The basic camera and object setup described above works well for very large scenes (e.g. millions of kilometers), but because the positions are still stored in the Transform.position values, it's insufficient if you need scenes that are gigantic (e.g. millions of lightyears). If you need scenes this large or even up to the size of the observable universe we live in, then you need to use high precision positions.

To enable this, tick the Use Origin setting in your SgtFloatingCamera component, this should add a new Floating Origin GameObject to your scene.

Next, add the SgtFloatingPoint component alongside all your SgtFloatingObject components.

This SgtFloatingPoint component used by both the camera and your objects stores a high precision universal position. The position is stored using Local X/Y/Z and Global X/Y/Z values. 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 and increment the global value.

When combined and used to their maximum, this allows them to accurately store positions of +- 461168601842738790400000000 meters, which is +- 48745559677 light years, or 4.87 billion light years, which is greater than the 46.6 billion light year radius of the observable universe.

NOTE: Using the high precision origin for the camera introduces the limitation that you cannot parent the camera to another GameObject, unless the parent is just for organizational purposes (e.g. it doesn't move or rotate). If you need to parent the camera to something, I recommend you use the SgtFollow component on your camera, this can be setup to follow another GameObject, with a given offset. The reason for this limitation is that the camera is now driven by the SgtFloatingPoint and SgtFloatingOrigin components.


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 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 Touch+

Lean Touch+

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





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





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.





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 GUI Shapes

Lean GUI Shapes

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





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!





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!





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.





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!





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

The base color will be multiplied by this.


Brightness

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


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.


MainTex

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


Mesh

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


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.


Detail

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


DetailTex

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


DetailScaleX

The detail texture horizontal tiling.


DetailScaleY

The detail texture vertical tiling.


DetailOffset

The UV offset of the detail texture.


DetailSpeed

The scroll speed of the detail texture UV offset.


DetailTwist

The amount the detail texture is twisted around the disc.


DetailTwistBias

The amount the twisting is pushed to the outer edge.


Near

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


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.


NearDistance

The world space distance the fade will begin from.




SgtAccretionMesh

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


Segments

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


SegmentDetail

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


SegmentTiling

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


RadiusMin

The radius of the inner edge in local space.


RadiusMax

The radius of the outer edge in local space.


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.


BoundsShift

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


[CONTEXT] Export Mesh

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.




SgtAccretionModel

This component is used to render a segment of the accretion disc.


Accretion

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




SgtAccretionNearTex

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


Width

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


Format

The format of the generated texture.


Ease

The ease type used for the transition.


Sharpness

The sharpness of the transition.


Offset

The start point of the fading.


[CONTEXT] Export Texture

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

The base color will be multiplied by this.


Brightness

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


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.


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


InnerMeshRadius

The radius of the meshes set in the SgtSharedMaterial.


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


OuterMesh

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


OuterMeshRadius

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


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.


Height

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


InnerFog

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


OuterFog

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


Sky

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


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.


CameraOffset

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


Lit

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


AmbientColor

The atmosphere will always be lit by this amount.


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.


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.


GroundScattering

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


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.


ScatteringStrength

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


ScatteringMie

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


ScatteringRayleigh

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


Night

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


NightSky

The 'Sky' value of the night side.


NightEase

The transition style between the day and night.


NightStart

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


NightEnd

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


NightPower

The power of the night transition.




SgtAtmosphereDepthTex

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


Width

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


Format

The format of the generated texture.


HorizonColor

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


InnerColor

The base color of the inner texture.


InnerEase

The transition style between the surface and horizon.


InnerColorSharpness

The strength of the inner texture transition.


InnerAlphaSharpness

The strength of the inner texture transition.


OuterColor

The base color of the outer texture.


OuterEase

The transition style between the sky and horizon.


OuterColorSharpness

The strength of the outer texture transition.


OuterAlphaSharpness

The strength of the outer texture transition.


[CONTEXT] Export Inner Texture

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.


[CONTEXT] Export Outer Texture

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.


DistanceMin

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


DistanceMax

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


HeightClose

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


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.


Width

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


Format

The format of the generated texture.


SunsetEase

The transition style between the day and night.


SunsetStart

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


SunsetEnd

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


SunsetSharpnessR

The sharpness of the sunset red channel transition.


SunsetSharpnessG

The sharpness of the sunset green channel transition.


SunsetSharpnessB

The sharpness of the sunset blue channel transition.


[CONTEXT] Export Texture

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.




SgtAtmosphereModel

This component is used to render the outer shell of an atmosphere.


Atmosphere

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




SgtAtmosphereOuterMesh

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


Rings

The amount of rings in the generated mesh.


Detail

The amount of edges around each ring in the mesh.


[CONTEXT] Export Mesh

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

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




SgtAtmospherePointer

This component points the current atmosphere to the rendering camera, allowing you to keep the atmosphere vertex density high near the camera. This should be used with the SgtAtmosphereOuterMesh component, or an exported mesh from it.




SgtAtmosphereScatteringTex

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


Width

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


Format

The format of the generated texture.


SunsetEase

The transition style between the day and night.


SunsetStart

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


SunsetEnd

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


SunsetSharpnessR

The sharpness of the sunset red channel transition.


SunsetSharpnessG

The sharpness of the sunset green channel transition.


SunsetSharpnessB

The sharpness of the sunset blue channel transition.


[CONTEXT] Export Texture

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.


MainTex

The base texture tiled along the aurora.


Color

The base color will be multiplied by this.


Brightness

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


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.


CameraOffset

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


Seed

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


RadiusMin

The inner radius of the aurora mesh in local space.


RadiusMax

The inner radius of the aurora mesh in local space.


PathCount

The amount of aurora paths/ribbons.


PathDetail

The amount of quads used to build each path.


PathLengthMin

The minimum length of each aurora path.


PathLengthMax

The maximum length of each aurora path.


StartMin

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


StartMax

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


StartBias

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


StartTop

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


PointDetail

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


PointSpiral

The strength of the aurora waypoint twisting.


PointJitter

The strength of the aurora waypoint random displacement.


TrailEdgeFade

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


TrailTile

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


TrailHeights

The flatness of the aurora path.


TrailHeightsDetail

The amount of height changes in the aurora path.


Colors

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


ColorsDetail

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


ColorsAlpha

The minimum opacity multiplier of the aurora path colors.


ColorsAlphaBias

The amount of alpha changes in the aurora path.


Near

Should the aurora fade out when the camera gets near?


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.


NearDistance

The distance the fading begins from in world space.


Anim

Should the aurora paths animate?


AnimOffset

The current age/offset of the animation.


AnimSpeed

The speed of the animation.


AnimStrength

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


AnimStrengthDetail

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


AnimAngle

The maximum angle step between sections of the aurora path.


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.


Width

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


Height

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


Format

The format of the generated texture.


NoiseStrength

The strength of the noise points.


NoisePoints

The amount of noise points.


NoiseSeed

The random seed used when generating this texture.


TopEase

The transition style between the top and middle.


TopSharpness

The transition strength between the top and middle.


MiddlePoint

The point separating the top from bottom.


MiddleColor

The base color of the aurora starting from the bottom.


MiddleEase

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


MiddleSharpness

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


BottomEase

The transition style between the bottom and middle.


BottomSharpness

The transition strength between the bottom and middle.


[CONTEXT] Export Texture

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.




SgtAuroraModel

This component is used to render a group of aurora paths.


Aurora

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




SgtAuroraNearTex

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


Width

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


Format

The format of the generated texture.


Ease

The ease type used for the transition.


Sharpness

The sharpness of the transition.


[CONTEXT] Export Texture

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.


Seed

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


Radius

The radius of the starfield.


Squash

Should more stars be placed near the horizon?


StarCount

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


StarColors

Each star is given a random color from this gradient.


StarRadiusMin

The minimum radius of stars in the starfield.


StarRadiusMax

The maximum radius of stars in the starfield.


StarRadiusBias

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


PowerRgb

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


ClampSize

Prevent the quads from being too small on screen?


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.


Temp

Temp instance used when generating the starfield


Variant

The coordinate index in the asteroid texture.


Color

Color tint of this star.


Radius

Radius of this star in local space.


Angle

Angle of this star in degrees.


Position

Position of the star in local space.




SgtBelt

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


OrbitOffset

The amount of seconds this belt has been animating for.


OrbitSpeed

The animation speed of this belt.


Lit

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


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.


AmbientColor

The belt will always be lit by this amount.


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.


Temp

Temp instance used when generating the belt.


Variant

The coordinate index in the asteroid texture.


Color

Color tint of this asteroid.


Radius

Radius of this asteroid in local space.


Height

Height of this asteroid's orbit in local space.


Angle

The base roll angle of this asteroid in radians.


Spin

How fast this asteroid rolls in radians per second.


OrbitAngle

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


OrbitSpeed

The speed of this asteroid's orbit in radians.


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.


Asteroids

The custom asteroids in this belt.




SgtBeltLightingTex

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


Width

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


Format

The format of the generated texture.


FrontPower

How sharp the incoming light scatters forward.


BackPower

How sharp the incoming light scatters backward.


BackStrength

The strength of the back scattered light.


BaseStrength

The of the perpendicular scattered light.


[CONTEXT] Export Texture

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.


Seed

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


Thickness

The thickness of the belt in local coordinates.


ThicknessBias

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


InnerRadius

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


InnerSpeed

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


OuterRadius

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


OuterSpeed

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


RadiusBias

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


SpeedSpread

How much random speed can be added to each asteroid.


AsteroidCount

The amount of asteroids generated in the belt.


AsteroidColors

Each asteroid is given a random color from this gradient.


AsteroidSpin

The maximum amount of angular velcoity each asteroid has.


AsteroidRadiusMin

The minimum asteroid radius in local coordinates.


AsteroidRadiusMax

The maximum asteroid radius in local coordinates.


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.


RollWithCamera

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


AvoidClipping

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




SgtDepth

This is the base class for depth calculations, allowing you to find how opaque the view is between two points.


Layers

The layers that will be sampled when calculating the optical depth.


Ease

The transition style between 0..1 depth.




SgtDepthCamera

This component calculates depth based on camera optical depth. This can be used by the SgtFlare to adjust size.


Resolution

The width & height of the camera RenderTexture in pixels.


Size

The width & height of the camera viewport in world space.




SgtDepthRaycast

This component calculates depth based on raycast depth. This can be used by the SgtFlare to adjust size.


MaxThickness

For the depth to return 1, the raycast must go through an object with this thickness in world space.




SgtDepthScale

This component allows you to scale the current GameObject based on optical thickness between the current camera and the current position.


MaxScale

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




SgtFastBillboard

This component rotates the current Gameobject to the rendering camera.


RollWithCamera

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


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

The base color will be multiplied by this.


Brightness

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


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.


Radius

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


CameraOffset

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


MainTex

The cube map applied to the cloudsphere surface.


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


Softness

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


Lit

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


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.


AmbientColor

The cloudsphere will always be lit by this amount.


Near

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


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.


NearDistance

The distance the fading begins from in world space.


Detail

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


DetailTex

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


DetailScale

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


DetailTiling

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


Mesh

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


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.


Width

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


Format

The format of the generated texture.


RimEase

The rim transition style.


RimColor

The rim color.


RimPower

The rim transition sharpness.


AlphaDensity

The density of the atmosphere.


AlphaFade

The strength of the density fading in the upper atmosphere.


[CONTEXT] Export Texture

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.


Width

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


Format

The format of the generated texture.


SunsetEase

The transition style between the day and night.


SunsetStart

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


SunsetEnd

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


SunsetSharpnessR

The sharpness of the sunset red channel transition.


SunsetSharpnessG

The sharpness of the sunset green channel transition.


SunsetSharpnessB

The sharpness of the sunset blue channel transition.


[CONTEXT] Export Texture

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.




SgtCloudsphereModel

This component renders the outer shell of a cloudsphere.


Cloudsphere

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




SgtCloudsphereNearTex

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


Width

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


Format

The format of the generated texture.


Ease

The ease type used for the transition.


Sharpness

The sharpness of the transition.


Offset

The start point of the fading.


[CONTEXT] Export Texture

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

The base color will be multiplied by this.


Brightness

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


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.


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.


CameraOffset

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


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


InnerMeshRadius

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


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


OuterMesh

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


OuterMeshRadius

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


OuterSoftness

Should the outer corona fade out against intersecting geometry?


Height

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


InnerFog

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


OuterFog

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


Sky

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




SgtCoronaDepthTex

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


Width

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


Format

The format of the generated texture.


HorizonColor

The horizon color for both textures.


InnerColor

The base color of the inner texture.


InnerEase

The transition style between the surface and horizon.


InnerColorSharpness

The strength of the inner texture transition.


InnerAlphaSharpness

The strength of the inner texture transition.


OuterColor

The base color of the outer texture.


OuterEase

The transition style between the sky and horizon.


OuterColorSharpness

The strength of the outer texture transition.


OuterAlphaSharpness

The strength of the outer texture transition.


[CONTEXT] Export Inner Texture

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.


[CONTEXT] Export Outer Texture

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.




SgtCoronaModel

This component renders the outser shell of a corona.


Corona

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




SgtDebris

This component handles a single debris object.


OnSpawn

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


OnDespawn

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


Pool

Can this debris be pooled?


State

The current state of the scaling.


Prefab

The prefab this was instantiated from.


Scale

This gets automatically copied when spawning debris.


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.


Target

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


SpawnInside

The shapes the debris will spawn inside.


ShowDistance

The distance from the target that debris begins spawning.


HideDistance

The distance from the target that debris gets hidden.


CellCount

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


CellNoise

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


DebrisCountTarget

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


ScaleMin

The minimum scale multiplier of the debris.


ScaleMax

The maximum scale multiplier of the debris.


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.


RandomRotation

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


Seed

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


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.


Target

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


SpawnInside

The shapes the debris will spawn inside.


ShowSpeed

How quickly the debris shows after it spawns.


ShowDistance

The distance from the follower that debris begins spawning.


HideDistance

The distance from the follower that debris gets hidden.


SpawnOnAwake

Should all the debris be automatically spawned at the start?


SpawnLimit

The maximum amount of debris that can be spawned.


SpawnRateMin

The minimum amount of seconds between debris spawns.


SpawnRateMax

The maximum amount of seconds between debris spawns.


SpawnScaleMin

The minimum scale multiplier applied to spawned debris.


SpawnScaleMax

The maximum scale multiplier applied to spawned debris.


Prefabs

These prefabs are randomly picked from when spawning new debris.




SgtFlare

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


Mesh

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


Material

The material used to render this flare.


FollowCameras

Should the flare automatically snap to cameras.


FollowDistance

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


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.


ZTest

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


DstBlend

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


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.


Format

The format of the generated texture.


Width

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


Color

The base color will be multiplied by this.


Ease

The color transition style.


SharpnessR

The sharpness of the red transition.


SharpnessG

The sharpness of the green transition.


SharpnessB

The sharpness of the blue transition.


[CONTEXT] Export Texture

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.


Detail

The amount of points used to make the flare mesh.


Radius

The base radius of the flare in local space.


Wave

Deform the flare based on cosine wave?


WaveStrength

The strength of the wave in local space.


WavePoints

The amount of wave peaks.


WavePower

The sharpness of the waves.


WavePhase

The angle offset of the waves.


Noise

Deform the flare based on noise?


NoiseStrength

The strength of the noise in local space.


NoisePoints

The amount of noise points.


NoisePhase

The angle offset of the noise.


NoiseSeed

The random seed used for the random noise.


[CONTEXT] Export Mesh

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.




SgtFlareModel

This component handles rendering of a flare.


Flare

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




SgtJovian

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


Color

The base color will be multiplied by this.


Brightness

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


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.


MainTex

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


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


Sky

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


Lit

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


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.


AmbientColor

The jovian will always be lit by this amount.


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.


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.


ScatteringStrength

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


Mesh

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


MeshRadius

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


Radius

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




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.


Width

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


Format

The format of the generated texture.


RimEase

The rim transition style.


RimPower

The rim transition sharpness.


RimColor

The rim color.


AlphaDensity

The density of the atmosphere.


AlphaFade

The strength of the density fading in the upper atmosphere.


[CONTEXT] Export Texture

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.


Width

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


Format

The format of the generated texture.


SunsetEase

The transition style between the day and night.


SunsetStart

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


SunsetEnd

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


SunsetSharpnessR

The sharpness of the sunset red channel transition.


SunsetSharpnessG

The sharpness of the sunset green channel transition.


SunsetSharpnessB

The sharpness of the sunset blue channel transition.


[CONTEXT] Export Texture

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.




SgtJovianModel

This component handles rendering of a jovian.


Jovian

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




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.


Width

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


Height

The resolution of the scattering transition in pixels.


Format

The format of the generated texture.


Mie

The sharpness of the forward scattered light.


Rayleigh

The brightness of the front and back scattered light.


SunsetEase

The transition style between the day and night.


SunsetStart

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


SunsetEnd

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


SunsetSharpnessR

The sharpness of the sunset red channel transition.


SunsetSharpnessG

The sharpness of the sunset green channel transition.


SunsetSharpnessB

The sharpness of the sunset blue channel transition.


[CONTEXT] Export Texture

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.


LightningSpawner

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


Age

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


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.


DelayMin

The minimum delay between lightning spawns.


DelayMax

The maximum delay between lightning spawns.


LifeMin

The minimum life of each spawned lightning.


LifeMax

The maximum life of each spawned lightning.


Radius

The radius of the spawned lightning mesh in local coordinates.


Size

The size of the lightning in degrees.


Detail

The amount of rows and columns in the lightning mesh.


Colors

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


Brightness

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


Sprites

The random sprite used by the lightning.




SgtMeshDisplacer

This component converts a normal spherical mesh into one displaced by a heightmap.


OriginalMesh

The original mesh we want to displace.


Heightmap

The height map texture used to displace the mesh (Height must be stored in alpha channel).


Encoding

The way the height data is stored in the texture.


InnerRadius

The mesh radius represented by a 0 alpha value.


OuterRadius

The mesh radius represented by a 255 alpha value.


HeightmapCutoff

If you want to bake in the water height, then set the cutoff level here.


ZeroCutoff

Make all samples below the cutoff have a height of 0?


[CONTEXT] Export Mesh

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

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




SgtPlanet

This component rotates the current GameObject.


Dampening

The speed the values changes (-1 = instant).




SgtPlanetMeshConverter

This component converts a normal spherical mesh into one suitable for the SGT Planet shader.


OriginalMesh

The original mesh we want to displace.


CapScale

The UV scale of the cap.


[CONTEXT] Export Mesh

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




SgtProminence

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


MainTex

The main texture of the prominence.


Color

The base color will be multiplied by this.


Brightness

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


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.


Seed

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


PlaneCount

The amount of planes used to build the prominence.


PlaneDetail

The amount of quads used to build each plane.


RadiusMin

The inner radius of the prominence planes in local coordinates.


RadiusMax

The outer radius of the prominence planes in local coordinates.


FadeEdge

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


FadePower

How sharp the transition between visible and invisible is.


ClipNear

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


ClipPower

How sharp the transition between visible and invisible is.


CameraOffset

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


Distort

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


DistortTex

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


DistortScaleX

The distortion texture horizontal tiling.


DistortScaleY

The distortion texture vertical tiling.


DistortStrength

The distortion texture strength.


DistortOffset

The UV offset of the distortion texture.


DistortSpeed

The scroll speed of the distortion texture UV offset.


Detail

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


DetailTex

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


DetailScaleX

The detail texture horizontal tiling.


DetailScaleY

The detail texture vertical tiling.


DetailStrength

The detail texture strength.


DetailOffset

The UV offset of the detail texture.


DetailSpeed

The scroll speed of the detail texture UV offset.




SgtProminenceModel

This component handles rendering of a prominence.


Prominence

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




SgtRing

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


Color

The base color will be multiplied by this.


Brightness

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


RenderQueue

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.


MainTex

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


Mesh

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


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.


Detail

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


DetailTex

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


DetailScaleX

The detail texture horizontal tiling.


DetailScaleY

The detail texture vertical tiling.


DetailOffset

The UV offset of the detail texture.


DetailSpeed

The scroll speed of the detail texture UV offset.


DetailTwist

The amount the detail texture is twisted around the ring.


DetailTwistBias

The amount the twisting is pushed to the outer edge.


Near

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


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.


NearDistance

The distance the fading begins from in world space.


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.


ScatteringMie

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


ScatteringStrength

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


Lit

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


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.


AmbientColor

The ring will always be lit by this amount.




SgtRingLightingTex

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


Width

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


Format

The format of the generated texture.


FrontPower

How sharp the incoming light scatters forward.


BackPower

How sharp the incoming light scatters backward.


BackStrength

The strength of the back scattered light.


BaseStrength

The of the perpendicular scattered light.


[CONTEXT] Export Texture

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.


Source

The source ring texture that will be filtered.


Format

The format of the generated texture.


Power

The sharpness of the light/dark transition.


Exposure

This allows you to control the brightness.


[CONTEXT] Export Texture

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.


Segments

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


SetSegments

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


SegmentDetail

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


SetSegmentDetail

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


RadiusMin

The radius of the inner edge in local space.


SetRadiusMin

The radius of the inner edge in local space.


RadiusMax

The radius of the outer edge in local space.


SetRadiusMax

The radius of the outer edge in local space.


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.


SetRadiusDetail

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.


BoundsShift

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


SetBoundsShift

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


Shadow

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


[CONTEXT] Export Mesh

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.




SgtRingModel

This component is used to render a segment of the ring mesh.


Ring

The ring this belongs to. If this is null it will automatically be destroyed.




SgtRingNearTex

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


Width

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


Format

The format of the generated texture.


Ease

The ease type used for the transition.


Sharpness

The sharpness of the transition.


[CONTEXT] Export Texture

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.




SgtBehaviour

This class allows you to quickly exit play mode or close the application by skipping code when quitting is true.




SgtBoundsD

This implements Bounds using the double data type.




SgtBoundsL

This implements Bounds using the long data type.




SgtCamera

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


RollAngle

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




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

The camera associated with this state.




SgtDepthTextureMode

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


DepthMode

The depth mode that will be applied to the camera.




SgtDocumentation

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




SgtEase

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




SgtEditor<T>

This is the base class for all SGT component inspectors.




SgtHelper

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




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.


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.




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




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


TypeName

The name of the type this pool manages.


Elements

The pooled elements in this pool.




SgtPoolObject

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


TypeName

The name of the type this pool manages.


Elements

The pooled elements in this pool.




SgtProcedural

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


Generate

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


Seed

The seed used for automatic generation.


GenerateWith

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




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

The base color will be multiplied by this.


SetColor

The base color will be multiplied by this.


Brightness

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


SetBrightness

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


MainTex

The main texture of this material.


Layout

The layout of cells in the texture.


LayoutColumns

The amount of columns in the texture.


LayoutRows

The amount of rows in the texture.


LayoutRects

The rects of each cell in the texture.


BlendMode

The blend mode used to render the material.


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.




SgtQuadsModel

This component handles rendering of a quads model.


Quads

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




SgtRectL

This implements a Rect using the long data type.




SgtRenderingPipeline

This object allows you to switch SGT material shaders between standard shader usage, and scriptable render pipelines (SRP) shaders.




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.


Radius

The radius of this shadow receiver.


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

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


RadiusMin

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


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.


Source

The source ring texture that will be filtered.


Format

The format of the generated texture.


Iterations

The amount of blur iterations.


ShareRGB

Overwrite the RGB channels with the alpha?


Invert

Invert the alpha channel?


[CONTEXT] Export Texture

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.


Width

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


Format

The format of the generated texture.


SharpnessR

The sharpness of the sunset red channel transition.


SharpnessG

The power of the sunset green channel transition.


SharpnessB

The power of the sunset blue channel transition.


Opacity

The opacity of the shadow.


RadiusMin

The inner radius of the sphere in local space.


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.


GetDensity

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.


Extents

The min/max size of the box.


Ease

The transtion style between minimum and maximum density.


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.


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.


Radius

The radius of this sphere in local space.


Ease

The transtion style between minimum and maximum density.


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.


Radius

The radius of this torus in local coordinates.


Thickness

The radial thickness of the torus in local space.


Ease

The transtion style between minimum and maximum density.


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

The material that will be applied to all renderers.




SgtVector2D

This implements Vector2 using the double data type.




SgtVector3D

This implements Vector3 using the double data type.




SgtVector3L

This implements Vector3 using the long data type.




SgtVector4D

This implements Vector4 using the double data type.




SgtSingularity

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


Mesh

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


MeshRadius

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


Radius

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


RenderQueue

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


PinchPower

How much the singulaity distorts the screen.


PinchOffset

How large the pinch start point is.


EdgeFade

To prevent rendering issues the singularity can be faded out as it approaches the edges of the screen. This allows you to set how the fading is calculated.


EdgeFadePower

How sharp the fading effect is.


HoleColor

The color of the pinched hole.


HolePower

How sharp the hole color gradient is.


Tint

Enable this if you want the singulairty to tint nearby space.


TintColor

The color of the tint.


TintPower

How sharp the tint color gradient is.




SgtSingularityModel

This component handles rendering of a singularity.


Singularity

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




SgtSpacetime

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


Color

The base color will be multiplied by this.


Brightness

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


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.


MainTex

The main texture applied to the spacetime.


Tile

How many times should the spacetime texture be tiled?


AmbientColor

The ambient color.


AmbientBrightness

The ambient brightness.


DisplacementColor

The displacement color.


DisplacementBrightness

The displacement brightness.


HighlightColor

The color of the highlight.


HighlightBrightness

The brightness of the highlight.


HighlightScale

The scale of the highlight.


HighlightPower

The sharpness of the highlight.


Displacement

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


Accumulate

Should the displacement effect additively stack if wells overlap?


Power

The pinch power.


Offset

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


RequireSameLayer

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


RequireSameTag

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


RequireNameContains

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




SgtSpacetimeWell

This component allows you to deform SgtSpacetime grids.


Distribution

The method used to deform the spacetime.


Radius

The radius of this spacetime well.


Frequency

The frequency of the ripple.


Strength

The minimum strength of the well.


Offset

The frequency offset.


OffsetSpeed

The frequency offset speed per second.


HoleSize

The size of the twist hole.


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.


PowerRgb

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


ClampSize

Prevent the quads from being too small on screen?


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.


Stretch

Should the stars stretch if an observer moves?


StretchVector

The vector of the stretching.


StretchScale

The scale of the stretching relative to the velocity.


StretchLimit

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


Near

Should the stars fade out when the camera gets near?


NearTex

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


NearThickness

The thickness of the fading effect in world space.


Pulse

Should the stars pulse in size over time?


PulseOffset

The amount of seconds this starfield has been animating.


PulseSpeed

The animation speed of this starfield.




SgtStarfieldBox

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


Seed

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


Extents

The +- size of the starfield.


Offset

How far from the center the distribution begins.


StarCount

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


StarColors

Each star is given a random color from this gradient.


StarRadiusMin

The minimum radius of stars in the starfield.


StarRadiusMax

The maximum radius of stars in the starfield.


StarRadiusBias

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


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.


Stars

The stars that will be rendered by this starfield.




SgtStarfieldElliptical

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


Seed

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


Radius

The radius of the starfield.


Symmetry

Should more stars be placed near the horizon?


Offset

How far from the center the distribution begins.


Bias

Invert the distribution?


StarCount

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


StarColors

Each star is given a random color from this gradient.


StarRadiusMin

The minimum radius of stars in the starfield.


StarRadiusMax

The maximum radius of stars in the starfield.


StarRadiusBias

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


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.


Softness

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


Far

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


FarTex

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


FarRadius

The radius of the fading effect in world coordinates.


FarThickness

The thickness of the fading effect in world coordinates.


Seed

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


Size

The size of the starfield in local space.


StarCount

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


StarColors

Each star is given a random color from this gradient.


StarRadiusMin

The minimum radius of stars in the starfield.


StarRadiusMax

The maximum radius of stars in the starfield.


StarRadiusBias

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


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.


Width

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


Format

The format of the generated texture.


Ease

The transition style.


Sharpness

The sharpness of the transition.


[CONTEXT] Export Texture

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.


Width

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


Format

The texture format of the generated texture.


Ease

The transition style.


Sharpness

The sharpness of the transition.


Offset

The start point of the fading.


[CONTEXT] Export Texture

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.


Seed

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


SourceTex

This texture used to color the nebula particles.


Threshold

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


Samples

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


Jitter

This allows you to randomly offset each nebula particle position.


HeightSource

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


ScaleSource

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


Size

The size of the generated nebula.


HorizontalBrightness

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


HorizontalPower

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


StarCount

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


StarColors

Each star is given a random color from this gradient.


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.


StarBoost

Should the star color luminosity be boosted?


StarRadiusMin

The minimum radius of stars in the starfield.


StarRadiusMax

The maximum radius of stars in the starfield.


StarRadiusBias

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


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.


Seed

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


Radius

The radius of the starfield.


ArmCount

The amount of spiral arms.


Twist

The amound each arm twists.


ThicknessInner

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


ThicknessOuter

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


ThicknessPower

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


StarCount

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


StarColors

Each star is given a random color from this gradient.


StarRadiusMin

The minimum radius of stars in the starfield.


StarRadiusMax

The maximum radius of stars in the starfield.


StarRadiusBias

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


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.


Variant

The coordinate index in the asteroid texture.


Color

Color tint of this star.


Radius

Radius of this star in local space.


Angle

Angle in degrees.


Position

Local position of this star relative to the starfield.


PulseSpeed

How fast this star pulses (requires AllowPulse).


PulseRange

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


PulseOffset

The original pulse offset (requires AllowPulse).




SgtTerrain

This component allows you to make a planet or star whose surface is procedurally generated, and has LOD based on camera (or another Transform) distance.


Material

The base material for the terrain. If you're using one material per face or something more complex then use the SgtTerrainMaterial or SgtTerraimCubeMaterials component instead.


SharedMaterial

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


HeightMap

This allows you to set the texture used to read height data from. The height data is read from the alpha channel.


HeightScale

This allows you to set the strength of the height map samples, where maximum alpha (255) increases the terrain height by this amount.


MaskMap

This allows you to set the detail texture mask, where the red channel is used for DetailMapA, and the green channel is used for DetailMapB.


DetailTiling

The allows you to set how many times the detail textures are tiled along the planet surface.


DetailMapA

This allows you to set the detail texture, where the alpha channel is used as the height source.


DetailScaleA

This allows you to set the detail texture strength, where maximum alpha (255) increases the terrain height by this amount.


DetailMapB

This allows you to set the detail texture, where the alpha channel is used as the height source.


DetailScaleB

This allows you to set the detail texture strength, where maximum alpha (255) increases the terrain height by this amount.


TargetMainCamera

If you want the LOD to update based on the distance to the main camera, then enable this.


Targets

If you want the LOD to update based on the distance to other transforms, then set them here.


Radius

The base radius of the terrain. This can be deformed by another component like SgtTerrainSimplex.


Normals

The strategy used to generate the normal maps. FixedStep uses the NormalStep setting as the sample distance. QuadStep uses the current quad size as the sample distance.


NormalStep

This allows you to set the sample distance when calculating the surface normal of a given point. A higher value leads to smoother results.


NormalStrength

This allows you to adjust the overall effect of surface normals.


Subdivisions

The detail of each LOD level.


Budget

The maximum amount of time that can be spent updating the terrain each frame in seconds.


CenterMesh

If you have a large planet then your terrain faces should be centered.


ForceCPU

Terrains will be generated using Compute Shaders if possible, but this can force them to use CPU.


CenterBounds

Should the bounds match the size of the terrain?


MaxColliderDepth

The maximum LOD depth that colliders will be generated for (0 = none).


Distances

The LOD distances in local space, these should be sorted from high to low.




SgtTerrainCompute

This class handles the GPU and CPU fallback for the SgtTerrain compute shader.




SgtTerrainFace

This component stores information about a particular terrain face, which can then subdivide/split into 4 child faces.




SgtTerrainLevel

This class stores LOD data for each terrain detail level.




SgtTerrainModifier

This is the base class for all components that modify or need to update with an SgtTerrain.




SgtTerrainNeighbour

This struct stores information about which terrain face is next to the current one.




SgtTerrainObject

This component can be added to prefabs to make them spawnable with the SgtTerrainSpawner.


OnSpawn

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


OnDespawn

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


Pool

Can this object be pooled?


ScaleMin

The minimum scale this prefab is multiplied by when spawned.


ScaleMax

The maximum scale this prefab is multiplied by when spawned.


AlignToNormal

How far from the center the height samples are taken to align to the surface normal in world coordinates (0 = no alignment).


Renderers

If this prefab is spawned on a terrain with an atmosphere, you can set the renderers you want to have use the atmosphere material here.


Prefab

The prefab this was instantiated from.




SgtTerrainPlane

This component generates a plane undernearth the current GameObject on top of the nearest terrain surface, allowing you to use physics on terrains without colliders.


Detail

The rows/columns of the collider plane.


Size

The size of the plane in world space.




SgtTerrainSpawner

This component allows you to spawn SgtTerrainObject prefabs on the surface of the terrain.


Depth

The patch depth required for these objects to spawn.


Seed

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


SpawnProbability

This decides how many prefabs get spawned based on a random 0..1 sample on the x axis.


SpawnCountMax

The maximum amount of objects that can spawn on each level if all probability checks hit.


HeightMin

The minimum terrain height required for these prefabs to spawn.


HeightMax

The maximum terrain height required for these prefabs to spawn.


Prefabs

The prefabs we want to spawn on the terrain patch.




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.


Throttle

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


Rigidbody

The rigidbody you want to apply the thruster forces to


ForceAtPosition

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


ForceMode

The force mode used when ading force to the Rigidbody.


ForceMagnitude

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


Create

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


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


Thruster

The thruster the scale will be based on.


Dampening

The speed at which the scale reaches its target value.


BaseScale

The scale value that's applied by default.


ThrottleScale

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


Flicker

The amount the ThrottleScale flickers over time.


FlickerOffset

The offset of the flicker animation.


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.


Scale

The scale of this camera (e.g. 10 = objects should be 10% of normal size, 100 = 1%, etc)


SnapDistance

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


Vector3>

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


UseOrigin

This allows you to set the universal position of this camera. If you don't set this then standard position shifting will be used.


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.


TryGetCamera

This will find the active and enabled camera with the matching scale, or return false.


IsRendering

This will return true if the attached Camera's culling mask includes the specified group.


GetPosition

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


CalculatePosition

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




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 will automatically spawn & despawn a prefab based on its float origin distance to the SgtFloatingOrigin.


DistanceMin

The minimum spawning distance in meters.


Prefab

The object that will be spawned when within distance.


DistanceMax

The maximum spawning distance in meters.


Clone

The currently spawned clone.


EnableInEditor

Spawn or despawn the LOD in the editor?




SgtFloatingObject

This component allows you to turn a normal GameObject into one that works with the floating origin system.

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

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

To correctly handle this scenario, you need to hook into the SgtFloatingCamera.OnPositionChanged event, and calculate new positions using the CalculatePosition method from the passed SgtFloatingCamera instance.


OnSnap

This is called each time this object's position snaps.


Point

This allows you to set the universal position of this object. If you don't set this then standard position shifting will be used.




SgtFloatingOrbit

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


Radius

The radius of the orbit in meters.


Oblateness

How squashed the orbit is.


Tilt

The local rotation of the orbit in degrees.


Angle

The curent position along the orbit in degrees.


DegreesPerSecond

The orbit speed.


Visual

If you want to display the orbit path, set the visual here. The visual should be in a child GameObject.


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.


Thickness

The thickness of the visual ring in local space.


Points

The amount of points used to draw the orbit.


Colors

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




SgtFloatingOrigin

This component marks the attached SgtFloatingPoint as the floating origin system's main point.


currentPointSet

Is CurrentPoint non-null?


currentPoint

If there is an active and enabled SgtFloatingOrigin instance, its attached SgtFloatingPoint will be set here.




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.


Position

The position wrapped by this component.


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


PositionChanged

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


[CONTEXT] Derive Position

If you're upgrading a normal SgtFloatingObject to one that uses SgtFloatingPoint, this method will automatically calculate the Position based on the origin.




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.


BaseScale

The scale of the object when at DistanceMin.


ScaleMultiplier

Scale is multiplied by this, allowing you to more easily tweak large scales.


DistanceMin

The distance where the scaling begins.


DistanceMax

The distance where the scaling stops.




SgtFloatingSpawnable

This component allows the current GameObject to be spawned using the SgtFloatingSpawner___ components.


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.


OnSpawn

This event gets called when this opened is spawned (int = seed).




SgtFloatingSpawner

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


Category

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


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.




SgtFloatingSpawnerOrbit

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


Count

The amount of prefabs that will be spawned.


TiltMax

The maximum degrees an orbit can tilt.


OblatenessMax

The maximum amount an orbit can be squashed.


RadiusMin

The minimum distance away the prefabs can spawn.


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.


Count

The amount of prefabs that will be spawned.


RadiusMin

The minimum distance away the prefabs can spawn.


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.


Count

The amount of prefabs that will be spawned.


Radius

The maximum distance away the prefabs can spawn in meters.


Offset

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


VelocityScale

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




SgtFloatingSpeedometer

This component monitors Point for changes, and outputs the speed of those changes to the Title text.


Point

The point whose speed will be monitored.


Title

The speed will be output to this component.




SgtFloatingTarget

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


WarpName

The shorthand name for this warp target.


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.


Point

The point that will be warped.


WarpTo

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.


Target

The point that will be warped to.


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.


PickDistance

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


CurrentTarget

The currently picked target.


Parent

The parent rect of the pin.


Rect

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


Title

The name of the pin.


Group

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


Warp

The warp component that will be used.


HideIfTooClose

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


WarpTime

Seconds it takes to complete a warp.


Smoothness

Warp smoothstep iterations.


Warping

Currently warping?


Progress

Current warp progress in seconds.


StartPosition

Start position of the warp.


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.


CellSize

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




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.


Category

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


Prefabs

The prefabs beloning to this spawn list.




Index

Thank you for using Space Graphics Toolkit ❤️

How do I upgrade?

What is Space Graphics Toolkit?

Where do I get more packs?

Why does each feature require so many components?

How do I use this from C#?

Are scriptable render pipelines (SRP) supported?

Is VR supported?

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

Accretion

Atmosphere

Aurora

Backdrop

Belt

Billboard

Cloudsphere

Corona

Debris

Flare

Jovian

Lightning

Planet

Prominence

Ring

Singularity

Spacetime

Star

Starfield

Terrain

Thruster

Universe



Assets

Lean Touch

Lean Touch+

Lean Localization

Lean Pool

Lean Transition

Lean GUI

Lean GUI Shapes

Paint in 3D

Destructible 2D

Space Graphics Toolkit

Planet Pack - Space Graphics Toolkit

Volumetric Audio



Versions

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

SgtAccretionModel

SgtAccretionNearTex

SgtAtmosphere

SgtAtmosphereDepthTex

SgtAtmosphereHeight

SgtAtmosphereLightingTex

SgtAtmosphereModel

SgtAtmosphereOuterMesh

SgtAtmospherePointer

SgtAtmosphereScatteringTex

SgtAurora

SgtAuroraMainTex

SgtAuroraModel

SgtAuroraNearTex

SgtBackdrop

SgtBackdropQuad

SgtBelt

SgtBeltAsteroid

SgtBeltCustom

SgtBeltLightingTex

SgtBeltSimple

SgtBillboard

SgtDepth

SgtDepthCamera

SgtDepthRaycast

SgtDepthScale

SgtFastBillboard

SgtFastBillboardManager

SgtCloudsphere

SgtCloudsphereDepthTex

SgtCloudsphereLightingTex

SgtCloudsphereModel

SgtCloudsphereNearTex

SgtCorona

SgtCoronaDepthTex

SgtCoronaModel

SgtDebris

SgtDebrisGrid

SgtDebrisSpawner

SgtFlare

SgtFlareMaterial

SgtFlareMesh

SgtFlareModel

SgtJovian

SgtJovianDepthTex

SgtJovianLightingTex

SgtJovianModel

SgtJovianScatteringTex

SgtLightning

SgtLightningSpawner

SgtMeshDisplacer

SgtPlanet

SgtPlanetMeshConverter

SgtProminence

SgtProminenceModel

SgtRing

SgtRingLightingTex

SgtRingMainTexFilter

SgtRingMesh

SgtRingModel

SgtRingNearTex

SgtBehaviour

SgtBoundsD

SgtBoundsL

SgtCamera

SgtCameraState

SgtDepthTextureMode

SgtDocumentation

SgtEase

SgtEditor<T>

SgtHelper

SgtHelper

SgtLight

SgtLightPointer

SgtLinkedBehaviour<T>

SgtPoolClass<T>

SgtPoolComponent

SgtPoolObject

SgtProcedural

SgtQuads

SgtQuadsModel

SgtRectL

SgtRenderingPipeline

SgtRenderQueue

SgtSeedAttribute

SgtShader

SgtShadow

SgtShadowLayer

SgtShadowRing

SgtShadowRingFilter

SgtShadowSphere

SgtShape

SgtShapeBox

SgtShapeGroup

SgtShapeSphere

SgtShapeTorus

SgtSharedMaterial

SgtVector2D

SgtVector3D

SgtVector3L

SgtVector4D

SgtSingularity

SgtSingularityModel

SgtSpacetime

SgtSpacetimeWell

SgtStarfield

SgtStarfieldBox

SgtStarfieldCustom

SgtStarfieldElliptical

SgtStarfieldInfinite

SgtStarfieldInfiniteFarTex

SgtStarfieldNearTex

SgtStarfieldNebula

SgtStarfieldSpiral

SgtStarfieldStar

SgtTerrain

SgtTerrainCompute

SgtTerrainFace

SgtTerrainLevel

SgtTerrainModifier

SgtTerrainNeighbour

SgtTerrainObject

SgtTerrainPlane

SgtTerrainSpawner

SgtThruster

SgtThrusterRoll

SgtThrusterScale

SgtFloatingCamera

SgtFloatingLight

SgtFloatingLod

SgtFloatingObject

SgtFloatingOrbit

SgtFloatingOrbitVisual

SgtFloatingOrigin

SgtFloatingPoint

SgtFloatingRoot

SgtFloatingScaler

SgtFloatingSpawnable

SgtFloatingSpawner

SgtFloatingSpawnerOrbit

SgtFloatingSpawnerRing

SgtFloatingSpawnerSphere

SgtFloatingSpeedometer

SgtFloatingTarget

SgtFloatingWarp

SgtFloatingWarpButton

SgtFloatingWarpPin

SgtFloatingWarpSmoothstep

SgtLength

SgtPosition

SgtSpawnList