Tags:

Utility Gameplay Clientside Fix Immersion Shaders Accessibility Tweak Cosmetics Visual

Author:

SalemStyles

Side:

Client

Created:

Aug 2nd at 12:17 PM

Last modified:

Aug 2nd at 12:33 PM

Downloads:

109

Latest release (for Vintage Story 1.22.0-pre.1 - 1.22.6, potentially outdated):
zzzzzzFrameForgeTSR_v2.5.1.zip  1-click install

Final Frame Studios Presents: FrameForgeTSR

What it does:

FrameForge TSR is a client-side performance and rendering mod for Vintage Story designed around one basic idea:

Make the game render less expensive frames, then use modern reconstruction and sharpening techniques to make those frames look better than you would expect.

This project has been a many-month-long development effort that originally grew out of the techniques and rendering systems I developed for my VS TrueScale 128 HD texture project this is mainly meant to go with that mod https://mods.vintagestory.at/vstruescalehd . That project needed a way to render a heavily upgraded HD texture environment at a lower internal resolution and then reconstruct the image back to a much higher-quality final frame.

FrameForge takes those ideas and turns them into a runtime system for Vintage Story itself.

Instead of simply lowering graphics settings and accepting a worse-looking image, FrameForge uses temporal upscaling, jitter, frame history, sharpening, anti-aliasing, adaptive resolution, and custom shader processing to recover detail after rendering at a lower internal resolution.

The result is intended to be:

Less rendering work → more available GPU headroom → reconstructed image → better performance without simply making the game look worse.

The mod also includes a collection of runtime performance systems that work independently of the game's normal rendering options. These include adaptive view-distance controls, storm/weather performance protection, particle management, AO/SSAO controls, bloom handling, and other rendering/runtime optimizations.

The performance systems were designed to use different mechanisms from OptiTime, so they should generally be able to coexist rather than attempting to modify the exact same systems. That said, Vintage Story's rendering pipeline is complicated, so if you find a specific combination that causes problems, please report it.

One of the reasons I built this in the first place is because I personally run Vintage Story on hardware that is... let's politely call it a potato. My stronger machine spends a lot of its time doing development work and running extremely long upscaler training sessions, sometimes for days at a time. 😅

So this isn't a theoretical "maybe this helps performance" project. A major goal has always been making the game playable on hardware where the normal rendering workload becomes difficult, without completely sacrificing image quality to get there.

How it works:

The main system is Temporal Super Resolution (TSR).

Rather than treating every frame as an isolated image, FrameForge uses information from previous frames along with controlled sub-pixel jitter and depth information to reconstruct the current frame.

This is fundamentally different from simply resizing an image with bilinear or bicubic interpolation.

A traditional resize essentially asks:

"What color should this larger pixel be based on the pixels around it?"

Temporal reconstruction can instead use information from multiple frames, motion/history information, depth, and shader calculations to determine where detail should actually belong.

FrameForge uses this temporal information to reconstruct edges and fine detail while the game is rendering internally at a lower resolution.

The mod also includes several selectable upscaling, anti-aliasing, and sharpening modes. Some of these are ports/adaptations of techniques from publicly available research and open-source implementations, including AMD FSR1-style processing and other established reconstruction/sharpening techniques.

The exact result depends heavily on the selected combination of:

• TSR quality
• TSR scale
• Temporal jitter
• History weighting
• Reactive strength
• Upscaler mode
• Anti-aliasing mode
• Sharpening mode
• Edge detection/edge treatment
• Sharpening strength
• Adaptive resolution settings

There are also multiple sharpening options because different textures and resolutions benefit from different amounts of sharpening. Too little sharpening can look soft, while too much can create halos and ringing, so these controls are intentionally exposed.

Anti-Aliasing

FrameForge also provides its own AA processing.

There is an SMAA option as well as an upgraded FXAA path that replaces the normal vanilla FXAA processing when FrameForge is handling that stage.

Important:
If you are using FrameForge's FXAA/AA processing, do not also enable the game's normal FXAA option, or you can end up stacking the two systems.

Ambient Occlusion

FrameForge also contains additional AO/SSAO controls, including strength, radius, bias, and related runtime controls.

These systems may eventually be moved or integrated more deeply into our upcoming Radiant Ruins shader project, so some of this functionality may evolve as that project develops.

Runtime Performance Systems

There are also two important performance systems outside of the actual upscaler.

Adaptive View Distance

FrameForge can dynamically adjust rendering distance depending on where you are.

It can treat environments differently, including:

• Forests
• Dense foliage/canopy
• Caves
• Indoor areas
• Open environments

The goal is to avoid spending the same amount of rendering power on distant geometry that is barely visible while maintaining normal view distance where it actually matters.

Storm Protection

The Storm Protection system is designed specifically for expensive weather conditions.

Rain, snow, sandstorms, and other weather effects can create large temporary rendering costs because of the number of particles and effects being processed.

FrameForge can respond to these conditions by reducing the cost of those systems client-side.

Depending on the selected settings, this can involve things such as:

• Reduced weather rendering distance
• Reduced particle counts
• Reduced heavy-weather particle counts
• Ambient particle reduction
• Particle pooling
• Particle limits
• Weather-specific performance thresholds
• Separate handling for heavy storms

The goal isn't to simply turn storms off.

The goal is to make them less expensive to render when they become a major performance spike.

Adaptive Resolution

FrameForge also contains an adaptive resolution system.

Instead of always rendering at one fixed internal scale, the renderer can adjust its internal rendering resolution based on performance targets.

This allows the mod to spend more GPU power when there is headroom and reduce internal rendering cost when the GPU is struggling.

The reconstructed image is then returned to the game's final rendering pipeline.  being worked on currently** I am trying to make it smoother and more natural. 

How to make it work:

There are a few important things you need to do before using FrameForge.

1. Open your Vintage Story client settings

Find:

glContextVersion

Set it to:

4.6

FrameForge uses compute shaders, and the required compute-shader functionality will not work correctly if Vintage Story is running with an insufficient OpenGL context.

If you do not have OpenGL 4.6 available, this mod is not going to function correctly.

2. Back up your saves

This is a client-side rendering/performance mod and should not be modifying your world data, but please back up your saves anyway.

Any mod that hooks deeply into the rendering pipeline deserves a little caution.

3. Set your Vintage Story resolution to 50%

This one is important.

Before entering your world, set your game's resolution scaling to 50% from the main graphics menu.

Then leave it there while using FrameForge.

FrameForge has its own internal resolution scaling and reconstruction system. It takes the lower-resolution render, processes it, reconstructs it, and sends the resulting image back through the rendering pipeline.

If you change the game's resolution scaling after FrameForge is already running, you can cause the internal scaling calculations to become mismatched.

So:

Main menu → Graphics → Resolution Scale → 50%

Then leave it alone.

Yes, you are absolutely welcome to experiment with it.

No, I cannot promise that it won't make the renderer do something extremely cursed. 😂

4. Open FrameForge's menu

The FrameForge configuration menu is opened with:

SHIFT + ,

That's Shift + comma.

There are multiple configuration tabs containing the TSR, upscaling, sharpening, performance, storm protection, AO, and runtime settings.

5. The presets are conservative

This is important because the default presets are intentionally designed to be conservative for lower-end hardware.

The mod is not intended to stop at a 50% internal render scale.

If your hardware can handle it, you should experiment with the FrameForge resolution/upscale controls and increase the reconstruction target.

The system is designed around upscaling the lower-resolution render back to the game's final resolution.

So if you have the GPU headroom, don't assume that the conservative preset is the maximum quality the system can provide.

Compatibilities and Incompatibilities:

FrameForge modifies several parts of Vintage Story's client-side rendering pipeline.

Because of that, it will most likely conflict with other shader/rendering mods that attempt to modify the same rendering stages.

FrameForge was specifically developed with our upcoming Radiant Ruins shader project in mind, and the two are being developed to work together.

Other shader mods may or may not work depending on exactly which rendering stages they hook into.

You are absolutely welcome to try combinations, but if two different mods are attempting to take control of the same render stage, shader, framebuffer, or post-processing operation, things can get interesting very quickly.

OptiTime

The performance systems in FrameForge were designed to operate through different mechanisms from OptiTime, so FrameForge and OptiTime should generally be stackable.

That said, there are a lot of variables involved in a modded rendering pipeline, so if you find a specific combination that causes instability, visual problems, or unexpected performance behavior, please report it.

Graphics cards

FrameForge was primarily developed and tested on NVIDIA hardware.

That does not mean it is NVIDIA-only.

It means that NVIDIA is currently the hardware platform I have had the most opportunity to test on.

If you are using AMD or Intel graphics and encounter shader compilation problems, visual artifacts, crashes, or unexpected performance behavior, please let us know.

The more hardware configurations we can test, the better we can tune the system.

And please be patient with us while we do it.

How to report bugs:

If something looks wrong, please send us information that lets us reproduce it.

The most useful things you can provide are:

1. A screenshot

If the problem is visual, take a screenshot.

Especially useful for:

• Flickering
• Ghosting
• Trails
• Strange sharpening
• Broken transparency
• Incorrect AO
• Upscaling artifacts
• Weird particles
• Missing geometry
• Weather problems
• Anything that simply looks... wrong

2. Your client-main.log

Please include your client-main.log when reporting rendering, shader, or runtime problems.

3. Tell us what settings you were using

If possible, include:

• GPU
• Vintage Story version
• FrameForge version
• TSR mode
• Upscaler mode
• AA mode
• Sharpening mode
• Resolution scale
• Other rendering/shader mods
• Whether OptiTime is installed

The more information we have, the less time we have to spend playing detective. 😅

Also, please remember that FinalFrame Studios does not use AI to write or generate our fixes.

That means when something breaks, an actual human has to investigate the rendering pipeline, reproduce the problem, figure out what the hell Vintage Story is doing, write the fix, test it, and then release it.

So fixes can take some time.

Please bear with us.

Special thanks:

A huge shout-out to Coriaender for helping me understand how to get compute shaders working properly inside Vintage Story.

Without that knowledge, FrameForge would not have been possible.

Seriously — big credit where credit is due.

Magic_Oldie also deserves a special thanks for relentlessly bugging people into helping, performing the first initial tests on the early versions, and providing feedback and insight while the system was still very much in the "what the hell did I just break?" phase of development.

And a massive thank-you to everyone over at Farms and Forges for helping test this project and for being one hell of a stand-up community.

If you're looking for a friendly Vintage Story server/community, go check them out:

https://discord.gg/ZbhmueUjD

You can also reach me through the mod development community here:

https://discord.gg/VwrjBSuWu

Thank you to everyone who has tested this, reported bugs, provided feedback, or simply put up with me breaking the renderer for months while trying to make it faster.

This project is still evolving, so if something isn't working quite right, let us know.

We'll keep tuning it.

                                                                                                                                                                           

                                                                                                                                                           AS ALWAYS feel Free to buy us a coffee :D