Transdimensional Phoenix

Reading a cubemap pixel by direction in Unreal Engine 5

Thu, 29 Jun 2023 00:00:00 +0000

In order to implement an early version of pre-rendered 2D skybox I needed to compare the skyboxes with sun enabled and disabled in order to obtain the required tinting of the sun for 2D skybox (so the sun doesn’t render on top of it, shining right through dense clouds).

This system is no longer used, now a texture mask is used instead to remove stars, sun and moon and other background objects from being rendered where the clouds are.

Here is the function for sampling the cube map:

FLinearColor USynesthesiaBlueprintFunctions::SampleTextureCubeByDirection(UTextureRenderTargetCube* RenderTarget, const FVector& Direction)
{
 if (!RenderTarget) return FLinearColor::Black;

 // Get the correct resource
 FTextureRenderTargetResource* RenderTargetResource = RenderTarget->GameThread_GetRenderTargetResource();
 if (!RenderTargetResource) return FLinearColor::Black;
 FTextureRenderTargetCubeResource* CubeResource = RenderTargetResource->GetTextureRenderTargetCubeResource();
 if (!CubeResource) return FLinearColor::Black;

 // Normalize the direction vector
 const FVector NormalizedDirection = Direction.GetSafeNormal();

 // Get the correct cube face for the normalized direction
 ECubeFace CubeFace = ECubeFace::CubeFace_NegX;
 const double MaxAbsValue = FMath::Max3(FMath::Abs(NormalizedDirection.X), FMath::Abs(NormalizedDirection.Y), FMath::Abs(NormalizedDirection.Z));
 if (FMath::Abs(NormalizedDirection.X) == MaxAbsValue) {
 CubeFace = NormalizedDirection.X > 0 ? ECubeFace::CubeFace_PosX : ECubeFace::CubeFace_NegX;

 } else if (FMath::Abs(NormalizedDirection.Y) == MaxAbsValue) {
 CubeFace = NormalizedDirection.Y > 0 ? ECubeFace::CubeFace_PosY : ECubeFace::CubeFace_NegY;

 } else if (FMath::Abs(NormalizedDirection.Z) == MaxAbsValue) {
 CubeFace = NormalizedDirection.Z > 0 ? ECubeFace::CubeFace_PosZ : ECubeFace::CubeFace_NegZ;
 }

 // Calculate coordinates of the point on the selected cube maps cube face
 float CubeFaceU = 0.0f;
 float CubeFaceV = 0.0f;
 const FVector FaceDirection = NormalizedDirection.GetAbs();
 if (CubeFace == ECubeFace::CubeFace_PosX) {
 CubeFaceU = -NormalizedDirection.Z / FaceDirection.X;
 CubeFaceV = -NormalizedDirection.Y / FaceDirection.X;

 } else if (CubeFace == ECubeFace::CubeFace_NegX) {
 CubeFaceU = NormalizedDirection.Z / FaceDirection.X;
 CubeFaceV = -NormalizedDirection.Y / FaceDirection.X;

 } else if (CubeFace == ECubeFace::CubeFace_PosY) {
 CubeFaceU = NormalizedDirection.X / FaceDirection.Y;
 CubeFaceV = NormalizedDirection.Z / FaceDirection.Y;

 } else if (CubeFace == ECubeFace::CubeFace_NegY) {
 CubeFaceU = NormalizedDirection.X / FaceDirection.Y;
 CubeFaceV = -NormalizedDirection.Z / FaceDirection.Y;

 } else if (CubeFace == ECubeFace::CubeFace_PosZ) {
 CubeFaceU = NormalizedDirection.X / FaceDirection.Z;
 CubeFaceV = -NormalizedDirection.Y / FaceDirection.Z;

 } else if (CubeFace == ECubeFace::CubeFace_NegZ) {
 CubeFaceU = -NormalizedDirection.X / FaceDirection.Z;
 CubeFaceV = -NormalizedDirection.Y / FaceDirection.Z;
 }

 // Read correct pixel from the resource
 TArray<FFloat16Color> ImageData;
 if (!CubeResource->ReadPixels(ImageData, FReadSurfaceDataFlags(ERangeCompressionMode::RCM_UNorm, CubeFace))) return FLinearColor::Black;

 // Calculate pixel coordinates of the point on selected cubemap face
 const int32 SizeX = CubeResource->GetSizeX();
 const int32 SizeY = CubeResource->GetSizeY();
 const int32 U = FMath::RoundToInt((CubeFaceU + 1.0f) * 0.5f * (SizeX - 1));
 const int32 V = FMath::RoundToInt((CubeFaceV + 1.0f) * 0.5f * (SizeY - 1));
 const int32 Offset = V * SizeX + U;

 // Sample the cubemap data
 if (ImageData.IsValidIndex(Offset)) {
 return ImageData[Offset].GetFloats();
 } else {
 return FLinearColor::Black;
 }
}

And here is the function for saving a cube map to disk, just in case it might be useful in a similar context:

UTextureCube* USynesthesiaBlueprintFunctions::RenderTargetCreateStaticTextureCubeEditorOnly(UTextureRenderTargetCube* RenderTarget, FString InName, TextureCompressionSettings CompressionSettings, TextureMipGenSettings MipSettings)
{
#if WITH_EDITOR
 // Save the render target image as an asset
 if (!RenderTarget) { // Invalid RT
 FMessageLog("Blueprint").Warning(LOCTEXT("RenderTargetCreateStaticTextureCube_InvalidRenderTarget", "RenderTargetCreateStaticTextureCubeEditorOnly: RenderTarget must be non-null."));
 return nullptr;

 } else if (!RenderTarget->GetResource()) { // Invalid RT resource
 FMessageLog("Blueprint").Warning(LOCTEXT("RenderTargetCreateStaticTextureCube_ReleasedRenderTarget", "RenderTargetCreateStaticTextureCubeEditorOnly: RenderTarget has been released."));
 return nullptr;

 } else { // Valid inputs, generate static texture
 FString Name;
 FString PackageName;
 IAssetTools& AssetTools = FModuleManager::Get().LoadModuleChecked<FAssetToolsModule>("AssetTools").Get();

 // Use asset name only if directories are specified, otherwise full path
 if (!InName.Contains(TEXT("/"))) {
 const FString AssetName = RenderTarget->GetOutermost()->GetName();
 const FString SanitizedBasePackageName = UPackageTools::SanitizePackageName(AssetName);
 const FString PackagePath = FPackageName::GetLongPackagePath(SanitizedBasePackageName) + TEXT("/");
 //AssetTools.CreateUniqueAssetName(PackagePath, InName, PackageName, Name);
 PackageName = PackagePath + InName;
 } else {
 InName.RemoveFromStart(TEXT("/"));
 InName.RemoveFromStart(TEXT("Content/"));
 InName.StartsWith(TEXT("Game/")) == true ? InName.InsertAt(0, TEXT("/")) : InName.InsertAt(0, TEXT("/Game/"));
 //AssetTools.CreateUniqueAssetName(InName, TEXT(""), PackageName, Name);
 PackageName = InName;
 }
 const int32 LastSlashIndex = InName.Find(TEXT("/"), ESearchCase::CaseSensitive, ESearchDir::FromEnd);
 if (LastSlashIndex != INDEX_NONE && LastSlashIndex < InName.Len() - 1) {
 Name = InName.RightChop(LastSlashIndex + 1);
 } else {
 Name = InName;
 }

 // Create the package
 UPackage* Package = CreatePackage(*PackageName);
 if (!Package) {
 UE_LOG(LogSynth, Error, TEXT("Failed to create package %s"), *PackageName);
 return nullptr;
 }
 Package->FullyLoad();

 // Create or overwrite the texture
 UTextureCube* NewTexture = Cast<UTextureCube>(RenderTarget->ConstructTextureCube(Package, Name, RenderTarget->GetMaskedFlags() | RF_Public | RF_Standalone));

 // If the texture is valid, set its parameters and return it
 if (NewTexture != nullptr) {
 // Package needs saving
 //NewTexture->MarkPackageDirty();
 Package->SetDirtyFlag(true);
 Package->PackageMarkedDirtyEvent.Broadcast(Package, true);

 // Notify the asset registry
 FAssetRegistryModule::AssetCreated(NewTexture);

 // Update Compression and Mip settings
 NewTexture->CompressionSettings = CompressionSettings;
 NewTexture->MipGenSettings = MipSettings;
 NewTexture->PostEditChange();
 return NewTexture;
 }
 FMessageLog("Blueprint").Warning(LOCTEXT("RenderTargetCreateStaticTextureCube_FailedToCreateTexture", "RenderTargetCreateStaticTextureCubeEditorOnly: Failed to create a new texture."));
 }
#else
 FMessageLog("Blueprint").Error(LOCTEXT("RenderTargetCreateStaticTextureCube_RuntimeFailedToCreateTexture", "RenderTargetCreateStaticTextureCubeEditorOnly: Can't create TextureCube at run time. "));
#endif
 return nullptr;
}

Synesthesia: Re-entry effects improvements

Wed, 28 Jun 2023 00:00:00 +0000

I have improved the sprite for the re-entry effect. It still needs some polishing, but now the re-entry effect looks like this up-close.

An extra bonus picture:

Plus a video of the sky, sun, moon and clouds all blending together with the mask:

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

Synesthesia: Starfield improvements

Tue, 27 Jun 2023 00:00:00 +0000

Tachy, a friend of mine, helped me considerably by calculating a star catalog for the year 2994 (when the events of the game take place). Some of the stars experience a considerable drift over the 1000 years - it might not be a very important detail to most players, however it is a nice little detail to have.

Here is a simple comparison between the two starfields:

The newer year 2994 catalog also contains way more stars - 119,614 total. The older catalog has been truncated to only magnitudes brighter than 9.99, so it only listed 28,593 stars.

The synths sensors are sufficiently sensitive to pick out faint stars, so in the end I plan to include all ~120,000 stars (though possibly less based on performance settings, however it does not seem to be considerable for the particle system).

Below are the two starfields in higher resolution. These images can be opened at a higher resolution, if you want to take a closer look.

Epoch 2000

Epoch 2994:

Here is the video of the star field movement over time and how it blends together with the clouds using the mask shown in an earlier post.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

Synesthesia: Debris re-entry effects

Mon, 26 Jun 2023 00:00:00 +0000

While working on the sky system, I had a thought about adding random space debris re-entering atmosphere. It would be a really telling and interesting piece of narrative that illustrates the state of the world - in the setting of Synesthesia, in year 2994, most of the space operations have been abandoned and overall there is no organized effort to monitor space debris anymore.

There are still millions of objects in orbit - many of these are private satellites, spacecraft and other assorted hardware. There are a few large objects (space stations and old spacecraft) which will eventually decay and re-enter atmosphere. All sorts of debris routinely enters the Earth atmosphere.

A large proportion of this debris is the result of the progressing Kessler syndrome, making any space travel dangerous and forcing people to abandon many of the space-based operations.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

The player would be able to see these happen randomly. Many of them may be too small to notice unless they get lucky, however there may be a really big event once in a while.

The re-entry effect is implemented as a particle system combined with a fairly simple thermal simulation. The debris objects are spawned at the height of about 120-140 km and are given a random, statistically distributed direction & entry angle.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

The objects continue to fly free and a simple break-up model is used to calculate when the object finally burns up. It is a fairly simplistic model, it is possible that I might improve it in the future.

One definite improvement I want to make is using better sprites - it would make the re-entry trails much more distinct, vivid, and less blurry. It would also emphasize multiple objects traveling in the re-entry path as the main object continues to shed debris.

The video below shows a better look at the hot entry and break up of the object. The re-entry event, if detected by players information systems, will also be recorded in the minor event log.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

The re-entry events are defined by the following parameters:

Object mass - this defines how much debris is generated and how long can the object withstand high temperature.
Burn rate - this defines how fast temperature burns up the mass of the object or causes debris shedding events. The effective burn rate is proportional to this value and the current temperature.
Entry vector - the simulation has a simple exponential model of atmosphere, so shallow and steep re-entries look distinctly different.

A combination of these parameters can be used to set up a re-entry that looks most artistically appealing. The sky system creates random procedural re-entry events. For special scripted events, the same particle system can be created manually and multiple systems can be combined to create an appearance of a very large object breaking up.

Here is a close-up picture of the re-entry event. For prototyping, I’ve been using a simple spherical sprite, which makes the entire trail look quite blurry. The quality should improve considerably when the sprite will be more drop-shaped, with a large glowing core and a small trail following it.

In addition to immersion, I want to include the re-entry effects in at least two elements of the narrative itself:

A side quest, during which the player can force a spacecraft in orbit to burn its engines for re-entry. While not having effect on the main quest, it would be narratively connected to the plot events.
- The destruction of this spacecraft would be done to hamper the mercenaries and Eden, the primary antagonists of the game.
- Most likely, this spacecraft will be an orbital weapon station, somewhat resembling SOL from Akira
A random event, during which an object re-enters over the EDZ-01 and visibly reaches surface.
- After re-entry, a glowing object falls somewhere in an obvious area, allowing player to go investigate and find this object.
- Possibly, the object is a new friend or an enemy, as well as some unique hardware.
- The side quest rewards player for the exploration they had to do in order to find the crashed object.

Synesthesia Gameplay Systems and Elements

Sun, 25 Jun 2023 00:00:00 +0000

(this entry is a work in progress, last updated: 2023-06-26).

These are the different elements considered or planned for Synethesia.

Narrative Gameplay Elements

These are the gameplay elements that enhance the narrative, provide extra flavor or information to player and may be used as part of a quest.

Computer terminals
- Similar to dialogs, but longer text replies and shorter user prompts.
- Computer terminals reveal extra lore information and allow triggering special events in the game world.
Dialogs with NPC’s
- The main way player interacts with the characters in the game world.
- Dialogs allow player to interact with the given character similarly to RPG games (I am using Fallout: New Vegas as a reference).
Background NPC dialogs
- Single sentence reactions NPC’s may say when player presses USE on them.
- These simply provide background flavor and indicate NPC’s which do not have a dialog tree.
Infoscan 1: Scanning landmarks or target zones
- Information or clues can be gained by manually scanning landmarks or target zones.
- Player enters the scanning mode by holding the SCAN key and points cursor at a landmark or a zone of interest. This reveals a short message that can be a helpful clue.
Event Log. Infoscan 2: Automatic landmarks or target zones
- Some landmarks get automatically scanned by simply approaching them. The short text is then added to the rolling event log.
- The event log also includes redundant text from other narrative elements, as well as general background noise for flavor.
- Some landmarks and clues are pretty obvious and are visible with the naked eye, however the infoscan system can still provide just a little bit of lore.
Radar
- Reveals hidden landmarks and passageways, reveals information unseen normally. Radar allows player to ‘see through walls’.
- Radar also provides a small 3D minimap that player can toggle.
Radio frequency scanning
- Produces audible noises, words, music, images and other narrative elements, plus flavor text and quest triggers.
- Most radio signals are produced by various landmarks around the city.
- Satellites that pass over player also produce radio signals, however most of them simply broadcast a dead carrier or repetitive telemetry.
Scavenger background chatter
- Text-based messages sent by scavengers to each other over their public network.
- Player can turn the optional messages off, however quest-specific text messages will still get delivered to player.
Enemy background chatter
- Communication between enemy AI units, coordination, reaction to player.
- These work similarly to scavenger chatter, however they are mostly produced by the dynamic AI system rather than world events.
Primary narrative
- The main quest that starts automatically and guides player into more of the game.
- The user interface that displays quest goals, quest log and other information.
- The quest markers.
- An extended event log that includes all dialogs and other text messages player has seen or heard.
Item descriptions
- Hovering over an inventory item will display its technical parameters as well as a general text description.
- These descriptions can contain unique lore beyond just technical specifications
- This includes notes and documents, as these items only present information through their description.
Technical drawings inspection mode
- A combination of player reward and extra lore, the game will let you view some select drawings in high resolution.
- This also includes things like maps and posters potentially, however this would be a fairly limited and minor element.

Functional Gameplay Elements

These are the elements that have to do with the actual primary gameplay loop.

WASD movement
- Standard first/third person shooter movement controls.
Lean left / right
- Character can lean left or right to “pie” corners.
Jumping
- Jump height is limited in this game in order to give a heavier feel to the player.
Climbing
- The character can climb moderately tall obstacles (1.6 m) in order to get to places that could not be reached otherwise.
- Same mechanic allows to vault over obstacles if they meet appropriate height.
Weapon length
- The player character has a unified rig. The weapons collide with the environment and deflect in order to fit in narrow spaces.
- This means that shorter guns would be required for comfortable use in-doors.
- It also requires player to be aware of their tactical positioning relative to obstacles. A long rifle can get stuck on an obstacle that is too close in front of the player.
Weapon condition
- Firing shots from the weapon depletes condition, requiring the weapon to be periodically repaired.
- Bullets impacting the weapon when it is in hands or in the backpack also degrade the condition, however the weapon provides some bullet protection.
Worn item condition
- Worn items have condition that degrades when player gets hit.
Primary / secondary reload
- Some weapons require two types of consumables (for example, bullets and fuel).
- Player can separately reload either consumable in the weapon.
Realistic gun mechanics and weapon failures
- The full cycle of the conventional weapons is recreated. Detailed simulation model allows for a more lively response of the weapon to failures.
- The intent is for player to get attached to their weapon, making it unique over the span of the game.
Weapon upgrades
- Weapons can be upgraded. All weapons have a generic set of upgrades that provide minor to moderate improvements to gun performance.
- Each weapon also has a gimmick upgrade tree, which boosts a single parameters of this weapon beyond reasonable values, allowing players to explore ultra-specific niches.
Environment hazards
- Various hazards drain players health points or disrupt their vision, hearing or other aspects of their operation.
Non-functional technical artifacts
- These items provide a short lore text message and are sold for an increased price.
- They can be widely found around the zone, making them almost clutter-like, however still fetching a good price.
Functional technical artifacts
- Some technical artifacts can have special functions or provide player with additional abilities.
- Additional items like the external targeting computer allow player to gain a corresponding perk from their perk tree while they are wearing the item.
- Technical artifacts may have expansion slots that change their operation or upgrade them.
- The functional technical artifacts can be found or bought from traders in very limited amounts.
Realistic ballistics
- A simulation model predicts ballistic dynamics of a bullet and energy dynamics of the weapon itself.
- Wind affects bullet path, as well as the weapon zeroing and physical parameters.
- This mechanic serves to limit the pace of the game to tactical, requiring higher care and skill to engage targets from longer distances.
- Bullet penetration.
No weapon sway, weapon holding dynamics
- Player experiences recoil from the weapon, however there is functionally no natural weapon sway.
- The players character is a synth with strong artificial muscles.
- Heavy weapons slow down the aim stabilization mechanics, leading to more inertia and less accuracy from rapid movements.
Data points / Experience points, Perks
- Works similarly to Fallout: New Vegas. Data points are awarded for performing various in-game actions, passing speech checks, completing quests and so on.
- Each time player levels up, they can select an additional perk that enhances their gameplay abilities or adds new features.
Inventory, in-world items and containers
- Player can pick up items in the world, from containers, from traders or from NPC bodies.
- The inventory is grid-based, where number of cells is proportional to the volume taken up by the item.
- Player has a dominant hand into which active weapon is equipped.
- The non-dominant hand is used to load and unload ammunition from the gun.
Harnesses
- Harnesses are special items which allow player to use a button to equip or use a specific item, usually a weapon.
- These can be found in the world and provide a different number of slots.
Backpacks
- Backpacks provide storage and can have multiple containers inside them.
Relief vests
- The relief vest allows the synth character to retrieve ammo for the weapon. Only ammunition from the vest will be accessible for the weapons usually.
- Ammunition that is too large and takes a longer time to reload is an exception to this.
Lower body armor
- Pants.
Upper body armor
- Body armor worn under relief and harness.
Left/right arm armor
- Left/right arm armor or special extensions.
Coat
- Clothes item worn on top of all other clothes.
Ladders
- Ladders that can take player up and down.
- While player is on a ladder, they cannot use the dominant hand item.
Item value categories
- Items can be contemporary/common/relic/artifact/ancient.
- This changes the strength of their effect, if they have one, and their price.
Repair items
- Items that allow player to restore their weapon condition, item condition or HP.
Medical items
- These items do not work on player, however they are highly valued by humans.
- Unlike the usual, the placement of these items is realistic and they are considerably rare.
Ammo abundance
- Some types of ammo are common and widely available.
- Exotic ammo can be limited in quantity or might require additional resources to obtain.
- Ammo can exist in damaged/outdated versions. Such ammo can degrade weapon condition faster or even damage it. Plus, it may have random ballistics.
- Ammo can be picked up from the enemies.
- Many of the mercenary outposts contain ammo caches.
- There are also ancient and just old ammo caches still left to uncover all around the zone. Many of these caches provide poor outdated ammo in large quantities.
Individual magazines/clips
- Each magazine is an individual object that must be loaded with individual bullet objects.
- Reloading can be done automatically by a button press, taking some time.
- Or can be done manually by dragging bullets into the magazine inside inventory.
- A pattern can be specified for a magazine. Changing the pattern does not unload the magazine, allowing to combine them.
Elevators and moving platforms
- These provide access to high areas or across large gaps, quickly.
Doors
- Some doors can be opened and closed to separate environments.
- Some doors are special and teleport player to an interior level.
- Many doors are permanently shut to limit the scope of the world, however all spaces are implied to have a realistic scale.

Scripted Events and Locations

Scavenger camps
- These act like quest hubs for human side quests and for the scavenger main quest line.
- Scavenger faction is neutral to positive about player.
- Humans offer a bigger variety of trading supplies at a higher cost.
Synth outposts
- Synths prefer small scattered outposts rather than having central camps like humans do.
- It is usually a source of synth-specific side quests.
- Some of the outposts have a trader willing to engage with the player.
- Synth traders tend to offer a small variety of items, however at a lower cost to the player.
Trading
- Traders are available in scavenger camps, at synth outposts and sometimes randomly in the world.
- Different traders provide items of a different kind, for different pricing.
- Items are priced based on a category. Each trader has a specialty, a set of items they provide at a lesser cost than any other trader.
- All traders can sometimes sell unique items.
Interiors
- The interiors are separate worldspaces that are not affected by the outside world.
- Some of the interiors are placed in the worldspace, however sparingly.
Crafting workbenches
- There are crafting workbenches placed throughout the world. They allow to combine some items in order to obtain another.
- These benches also allow player to repair weapons without repair items.

(to be expanded)

Synesthesia: Gameplay systems and elements

Sun, 25 Jun 2023 00:00:00 +0000

Primary Gameplay Loop

The primary loop is explore - cover - shoot. The player moves around complicated urban terrain, engaging human and creature enemies in tactical gunfights, managing their resources (maintaining weapons, keeping up with ammo counts, making sure equipment matches the enemies player is facing).

The game is influenced by S.T.A.L.K.E.R. series, Fallout: New Vegas and Arma 3. The primary activities in this game are:

Searching for technical artifacts
Interacting with NPC characters
Engaging in gunfights
Exploring the environment
Doing special narrative quests
Managing ammunition and supplies, weapon condition

→ Synesthesia Gameplay Systems and Elements

Synesthesia: Improved starfield rendering + satellites

Sat, 24 Jun 2023 00:00:00 +0000

While working on the new pre-rendered skybox system for Synesthesia, I came up with a way to render a cloud mask that would allow masking out objects that are supposed to be located behind the clouds - since skybox is a two-dimensional opaque image, there is no “behind”, things could only possibly render in front of this image.

However, with the cloud mask, objects that are rendered in front can be masked to appear behind, by concealing parts of them which are supposed to be hidden. Because of this, a possibility opened up to render a realistic star sky.

The stars are rendered as Niagara particles and placed slightly in front of the sky sphere. While I did not finish this yet, the stars will be masked by the cloud mask, allowing them to appear correctly behind the cloud.

The stars are defined by a catalog, where right ascension (azimuth) and declination (elevation) are specified. For now, I took a catalog that is relevant to present time, however it would be fun to produce a star catalog for year 2994 (when the game takes place).

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

The video above shows a timelapse and a few satellites passing over. The satellites are indicated by a red glow for now, however I will add proper calculations for their apparent magnitude.

The ring of satellites that appear to be frozen are an array of 36 geostationary satellites with a 10.0 degree step. They have an orbit defined as geostationary, I used them to verify orbital calculations and alignment between the starfield, the satellites and the geographical location of the observation.

Although there is a specific location encoded internally in the game, the exact location of EDZ-01 (the city that you explore in Synesthesia) should be assumed ambiguous.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

The video above shows movement of the satellites at the in-game time scale. Currently, 24 in-game hours take 2.4 hours of real world time. I may revise the scale in the future, however this seems to be optimal for the sort of gameplay that I have in mind. To compare, the same time of day scale is found in S.T.A.L.K.E.R.

To support a large number of satellites the simulation code works like this:

When it is first initialized, the time when satellite will become visible is pre-calculated. The satellite position is estimated at 5 minute intervals until position that is visible is found
If satellite is visible, it is added to the visible satellites list. If a satellite drops below the horizon in this list, it is removed and added to the sorted satellite list.
The sorted satellite list stores all satellites that are not visible in the order of next encounter.
Every tick, the sorted satellite array is scanned until the first satellite that is still too early to encounter is found. In practice, this means that only a small handful of satellites at the start of the list will be checked. These satellites are removed from the sorted list and added to the visible list.

Satellites are defined by a catalog, where six orbital elements and two extra parameters are specified:

Semi-major axis (SMA)
Eccentricity (ECC)
Inclination (INC)
Right ascension of ascending node / longitude of the ascending node (RAAN)
Periapsis argument (PAR)
Initial mean anomaly (MA0)
Tumble period: if the satellite is tumbling, its brightness is modulated with this period
Apparent magnitude: apparent magnitude of the satellite under the best conditions

The satellite system provides extra immersion and flavor to the setting, but also I plan a RF scanning feature, where player can listen in to various radio signals. Many of these satellites are no longer operationally used, however they still likely broadcast a dead carrier or some sort of telemetry data that player would be able to receive (however, most of it would be procedural and meaningless, just for flavor).

Synesthesia: Starfield rendering

Fri, 23 Jun 2023 00:00:00 +0000

See the previous post for more about how the skyboxes work in Synesthesia. One of the issues with the pre-rendered skyboxes is that the image of the stars in the background cannot properly rotate with the movement of sun.

The stars rotate over the sky as time progresses due to the rotation of Earth. However, since the stars must be behind the clouds and the current implementation of the pre-rendering cannot capture a mask of where the clouds are, it’s just embedded in the sky texture.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

On the video above, pay attention to the top middle of the frame. There are two prominent stars there which appear to teleport around in a strange way - a consequence of them being embedded in the sky texture as it blends.

Compare this to the way true dynamic sky behaves, shown on the video below. The star map correctly rotates with the movement of Earth.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

With some modification of the skybox renderer, it should be up to the task of rendering raw opacity of the cloud. This would allow separating the star map away from sky texture, making it scroll smoothly. It would also significantly improve the way the sun and the moon interact with the clouds.

While writing this post, I experimented a little with some simple modifications and got a result that I think will be practically useful. Here’s an example of a pre-rendered sky and a pre-rendered cloud mask. This cloud mask would allow distinguishing objects in front and behind the clouds accurately.

Hover over the mask below to see the corresponding pre-rendered skybox texture:

Synesthesia: Pre-rendered 2D skybox

Thu, 22 Jun 2023 00:00:00 +0000

In Synesthesia, the sky is displayed by taking a skybox cubemap texture and applying it to the sky sphere surrounding the game world. This texture is pre-rendered and stored on disk, allowing the sky to be displayed at a very small performance cost.

I have now improved the skybox system to support a full day/night cycle, including the smooth movement of the sun and the moon. Because each skybox texture must be a static picture the sun and the moon are superimposed on top of the clouds, allowing them to move smoothly.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

The skybox textures are pre-rendered inside the engine using a custom baking tool from a custom volumetric sky shader that uses the Unreal Engine volumetrics to render the clouds. Many skies are pre-rendered to allow the skybox to smoothly blend between different times of day and weathers.

For example, with the default 30 minute time interval, this means that 48 textures will be created for a single weather for the full span of a 24-hour day.

The sky system loads only the sky textures that are currently relevant and then blends between the two textures for the specified time of day, or blends between multiple textures in case the weather is changing.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

Since the 2D skybox pre-rendering process cannot properly capture a mask for cloud opacity/transparency right now, to avoid the sun and the moon always appearing to be on top of the clouds their brightness is adjusted based on a pre-calculated curve.

In order to mask the sun when it goes behind the clouds, the bake tool captures two versions of the scene - one with light sources enabled, another one with light sources disabled. It will then compare the brightness of the pixel where sun is located.

If the two brightness values are nearly equal, the sun is blocked by the clouds. If the two brightness values are different, then the sun is not concealed.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

This works good enough for both sun and moon. The version of the scene with light sources disabled is the one that gets saved to disk and later used with the 2D skybox.

Here is an example set of the pre-rendered skybox textures for a specific weather. The sun and moon are omitted and will be later superimposed on top of this texture when it is rendered in-game:

This method for skyboxes is highly performant and gives me a lot of artistic control. It does have some flaws, one of which I will demonstrate in the next post.

Some of the limitations of these pre-rendered skies:

The clouds within the same weather never move and are fully static. I could potentially fix this by allowing clouds to evolve during the capture process, however the clouds would have to somehow create a looping animation to avoid a discrepancy in cloud positions.
The star map blends in discrete steps, rather than smoothly rotating. I will update the star map with a generic texture so this effect wouldn’t be noticeable. However, see the next post for more about this.
The sun/moon do not interact with clouds in a satisfying way. They simply get darker or brighter, plus the curve doesn’t perfectly interpolate. But this isn’t very noticeable
Weather transitions are simplistic and there are no nice intermediate states. Also a limitation, the only way to transition between two weathers is to directly blend between them.

My intent is to solve most of the visual issues by providing a large pool of different skyboxes. Since they can be very easily generated and created, there can be enough interesting skies to look at so the other problems don’t matter as much.

Synesthesia: General description

Wed, 21 Jun 2023 00:00:00 +0000

Short Blurb

In this open-world roleplaying videogame, you play as a manufactured lifeform (a synth) waking up in a world in crisis. It is a first/third person tactical shooter, your goal is to collect valuable technical artifacts and documentation to help humans revive their golden age and save their civilization.

However, the old cities are now dangerous, full of industrial accidents and decaying infrastructure, making them Environmental Disaster Zones filled with lost treasures from the golden age. You were lost in transit for 200 years, but now it’s up to you whether to help humans or follow your own interests.

Long Blurb

With advancements in science, humanity has finally reached post-scarcity, but over time got complacent with the miracles of technology of the new era. You play as a manufactured lifeform (a synth), waking up in a world in crisis, a world that can no longer maintain its complex infrastructure and systems.

The game is a first/third person tactical shooter with roleplaying elements, focusing on urban exploration and urban combat. The primary goal is to collect technical artifacts and documentation, highly valued by humans with hopes that some of this old world information could help them revive the golden age of the old and stop the fall of their civilization.

As the crisis grew, the old cities became dangerous, full of industrial accidents, decaying infrastructure. Toxic hazards, radiation leaks, electromagnetic dangers all turned some of the largest cities into Environmental Disaster Zones - exclusion zones, full lost treasures and miracles from the golden age.

The players character was lost in transit and forgotten about as the world around descended into disarray, stranding them in a dream-like state for around 200 years. Now, it is up to you on whether you want to help humans in their pursuit of technology that may save their world, or follow your own interests.

Spoiler tags for Hugo

Tue, 20 Jun 2023 00:00:00 +0000

I use Hugo to generate the static HTML pages for this website. One of the projects I’m working on involves a storyline which some of my friends do not want spoiled to them. So for this, I had to add a simple spoiler shortcode.

This spoiler shortcode works like this: in-line spoilered content. It can be used to mask out individual phrases or whole blocks of text, as seen below.

An entire paragraph can be put into a spoiler tag. Each spoiler tag is clickable individually, and they can be clicked again to hide the text. They do not require any additional code as they are based on the checkbox functionality. A simple extra style sheet and the shortcode template file are all that's required.

Here is the source code to the spoiler tag functionality on my website:

// /theme/assets/css/spoiler.css

.spoiler_dummy {
 display: none;
}

.spoiler_dummy:checked + label {
 color: $color;
 background: $background;
 transition: color 0.3s ease, background 0.3s ease;
}

.spoiler {
 position: relative;
 display: inline-block;
 cursor: help;

 border-radius: 2px;

 color: black;
 background: black;
 transition: color 0.3s ease, background 0.3s ease;
}

<!-- /theme/layouts/shortcodes/spoiler.html -->

<input class="spoiler_dummy" type="checkbox" id="spoilerTag{{ .Ordinal }}"/>
<label class="spoiler" for="spoilerTag{{ .Ordinal }}">
 {{- .Inner | safeHTML -}}
</label>

Mon, 01 Jan 0001 00:00:00 +0000

Phoenix | About Me

Location: Concord, CA 94521

Telephone: +1 (925) 768 1562

Email: phoenix@foxworks.cz / fluffy.vuuli@gmail.com

I am a multi-specialist with focus on systems engineering, simulation and game development. My interest is in creating immersive interactive experiences, designing and organizing projects at a high level, providing inter-disciplinary help to the team and connecting different specialists together.

My main strength is understanding of the many disciplines across engineering and game development scopes, allowing me to help the rest of the team to understand the project as a whole and to be able to integrate together work of many individuals.

Project: Subtransit / Subtransit Drive

(headphones suggested for the video)


Status	Released on iOS/Android
Engine	Unreal Engine 4 / Unreal Engine 5
Homepage	https://subtrans.it/en
iOS	https://apps.apple.com/us/app/subtransit-drive/id1636723806
Android	https://play.google.com/store/apps/details?id=llc.wagon.subtransitdrive

Subtransit is an industrial-grade engineering train simulator that presents the detailed behavior of the trains and infrastructure around them, featuring digital twin systems simulation and a custom physics engine for detailed movement dynamics. It is a type of a simulation game where every button and switch work exactly as they should in real life.

This project was developed with full VR support, however currently a VR version is not publicly available. Subtransit Drive is a version of this simulator for mobile platforms and consoles.

I have done the following work for Subtransit:

Engineering & reverse-engineering, technical documentation work, research
Developing the mathematical models for the train hardware and infrastructure of the metro line, traffic model and more
Physics & simulation programming (C++)
Gameplay programming for desktop and VR modes (C++ / Blueprint)
Editor and custom toolset programming (C++ / C#)
Custom Blender plugin programming (Python)
Designing the game systems and their integration
Technical art and custom shaders, rendering tech for different parts of the game (HLSL / Material Editor)
3D modeling and texturing, additional 2D art, user interface concepts
Technical photography, sound recording and texture sources
Sound design and integration with the game systems
Creating the artistic, programming and other workflows for the rest of the team
Organizing the production process
Writing public-facing materials, promotional and other texts

Additionally, for Subtransit Drive:

Developing the optimization methodology for PC-level assets to be used with a mobile level platform
Advanced performance and memory optimizations, in-depth processing & memory profile analysis
Vertex animation system and mobile platform specific large crowd rendering
Porting the gameplay and simulation code for use with mobile platforms

Subtransit: Custom Physics Engine

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

I developed the custom physics engine used by Subtransit for wheel vs rail collision. It provides realistic dynamics of motion for the train in 3D space. The train is not affixed to the spline, but rather stays on track by responding to dynamic forces happening between the wheel and the rail.

This physics engine simulates per-wheel slip, hunting motions and other elements contributing to dynamics of movement experienced by the train. This allows the game to present train physics with high degree of accuracy, and these same physics forces drive the immersive movement of the in-game camera.

The custom physics engine provides collision response forces between the rail and the wheels and integrates with PhysX or Chaos in Unreal Engine. The integration work required making modifications to the Unreal Engine source code, and have been since integrated with the engine itself.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player. Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

Subtransit: Simulation & Engineering

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

I have created mathematical simulation models of all elements of the train hardware, signalling infrastructure and other elements of the subway train network based on analyzing engineering documentation and doing reverse engineering myself.

As part of my duties I have done drafting / technical drawings for many different elements of the train system, as well as documenting the reverse engineering results. Presenting and documenting my work to the rest of the team members has been a large part of it.

Part of this work involved architecture, civil engineering and related disciplines to pave the way for accurate recreations of the real world, including when insufficient information was available.

Subtransit: Technical & Art Workflows

I have created the technical and art workflows for Subtransit after completing every kind of work required for the project myself, then working with feedback from the team to iron out and make these workflows most suitable for our specific uses.

These workflows are still used by the team to continue work on new content & assets for the game. The documentation I wrote is now the basis for training new employees on the project or quickly bringing our external contractors up to date with internal knowledge at the company.

These workflows also teach team members the use of the custom toolset I developed for this project, that significantly speeds up quality and speed of work. These assorted tools are used at various stages of the working process to speed up measurements and work-specific calculations, create specific inputs to artistic processes.

Subtransit: 3D Modeling and Texturing

I have created most of the environment (world) textures in the current release of the game, as well as the initial versions for many of the 3D models used in the game before they were passed on to other artists.

Understanding the art process together with technical aspects of the engine & rendering tech that I set up allowed us to develop some advanced optimization and rendering techniques to give our game the graphics fidelity that it has, at a very low cost to our budget and development time.

The tools used for texturing work were Substance Painter, Photoshop, Agisoft Photoscan, and some custom tools. All of the 3D modeling has been done in Blender.

I have done a large proportion of technical photography for creating references and texture sources, as well as organized other team members to do it when I was not available, helped with sound recording. Together with their help, we have taken about a hundred thousand photos, recorded thousands of hours of sound.

Subtransit: Technical Art

All of the technical art work on this project has been done by me. I have developed a custom approach for efficient and visually appealing rendering of the train tunnels, computer screens inside the trains, the rails and vehicles themselves and much more.

This work included C++ engine modifications, as well as HLSL shader work combined with the Unreal Engine material editor. Most of visual aspects of this project are customized and tailored to our needs in some way, allowing us to save artist time or obtain higher fidelity at a lower cost.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

The tunnel rendering required a custom Blender plugin to pre-bake special texturing data into the mesh, a special shader that mixes the different layers and elements of the texture together, resulting in a seamless high quality tunnel, rendered at a low cost. I also optimized the same rendering tech for use on the limited mobile phone/console platforms.

All tunnel graphics are referenced to engineering drawings, and together with the track layout system that I wrote they let us recreate the accurate real world train tunnels, in the physics and visual regards.

The visual assets I created for this project and as an example have then been used by other members of the team to continue producing new assets according to this workflow.

I have also developed a crowd rendering system for Subtransit that works on the mobile platforms. It allows cheap simulation of “AI” for the individual passengers, adheres to a global traffic model that ensures the passenger flows are realistic and depend on the specific time-of-day and travel direction, and cheap passenger rendering.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

Subtransit: Sound Design

I developed the sound engine for Subtransit based on the FMOD Sound System. It uses multiple parallel DSP channels and clever mixing set up between them, tailored to the target scene to simulate sound propagation in realtime, without having to involve high intensity calculations.

Many of the sounds in the game were recorded by me, before I gave this work to other team members. All sounds in Subtransit are recorded from the real conditions, edited and processed, and then attached to a physics model for maximum responsiveness. All sound cues are generated by the physics / systems simulation models and depend on the current conditions.

Project: Synesthesia

Synesthesia is a side project I’ve been working. It is a highly systemic game, an open world tactical shooter with RPG elements.

This game is a playground for testing many of the systems I have developed:

An open world persistency system, tracking progress of player and objects they may have moved around in the world, state changes.
An advanced custom AI system for game enemies, based on soft feedback loops rather than a state machine
Weapon simulation models, for calculating the detailed mechanics of each weapon and creating a responsive and immersive feel for the player
A ballistic system for the projectiles
Assorted gameplay systems, such as the unified rig and its behaviors in tight spaces
Different special effects that integrate with the gameplay

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

Project: 4D Raytracer

A raytracer that works in four spatial dimensions (XYZW) for 4D rendering. I built it to study the behavior of four dimensional space and as an art project. It is written in C and is fully multi-threaded.

It supports signed distance fields, a collection of basic 4D primitives and tetrahedron-based 4D mesh rendering.

Sorry, your browser doesn't support embedded videos. You can download it and watch it with an external player.

About

Mon, 01 Jan 0001 00:00:00 +0000

My name is Phoenix…

…and this is my personal website. Here I post articles, updates about my personal projects and anything else I want here. My interests are complex systems engineering, art, writing, programming, music, architecture, drafting and many other things.

You can contact me here: fluffy.vuuli@gmail.com