Home / .NET / Game

A fully-dynamic voxel-based global illumination system for Unity

SEGI A fully-dynamic voxel-based global illumination system for Unity. More details at http://www.sonicether.com/segi/ Installation Check the Releases
Information
Category: .NET / Game
Watchers: 122
Star: 1.2k
Fork: 142
Last update: Dec 2, 2021
Resource links
http://www.sonicether.com/segi/
https://github.com/sonicether/SEGI

SEGI

A fully-dynamic voxel-based global illumination system for Unity. More details at http://www.sonicether.com/segi/

Installation

Check the Releases section above to download a version of SEGI that is a simple .unitypackage file which is ready for you to import into your project.

You can also click the "Clone or Download" button and select "Download Zip", then extract the contents to "Assets/SEGI" in your project to test out the latest unreleased versions of SEGI.

All the scripts and files for SEGI must be in "Assets/SEGI" for SEGI to fully function properly in your project.

Please refer to the User Guide.pdf for usage instructions.

Community

If you need some help, feel free to ask any questions in the official thread on Unity forums.

8 Open More issues
Closed

SEGI Cascaded crashing

No problems using SEGI on my camera, but when I use SEGI Cascaded, my screen goes black and after a short while Unity screen is all black. Windows notify that my video board stopped working and recovered from an issue, or something like it.

Happens instantly and all the time.

Reproduction: On a clean project, add SEGI Cascaded to the camera.

Using SEGI: SEGI.v0.9.0

My hardware is: Core i7 Q740 NVIDIA GeForce GTX 460M Windows 7 Unity 2017.1

opened Sep 23, 2017 by Dunathan 5
Closed

Fix SEGIVoxelizeScene_C interlockedAddFloat4 function causing crashes

opened Sep 24, 2017 by nxrighthere 2
Closed

Moved redundant functions in separate files

Hi, I noticed a few redundant bits in the Voxelization/Tracing shaders, for both the standard and cascaded versions, so I refactored those into separate files.

Changes:

  • utility functions (rgb <-> hsv, rgba encode/decode, interlocked add) moved to SEGIUtils.cginc
  • shader structs and vertex function moved to SEGIShaderCommon.cginc

This makes shaders significantly shorter.

opened Oct 6, 2017 by merwaaan 1
Closed

Fix flickering when the scene view and the game view are opened at the same time

Requested by users.

opened Jul 20, 2018 by nxrighthere 0
Closed

Fixes and improvements

opened Sep 26, 2017 by nxrighthere 0
Closed

#16 -> #13

opened Sep 24, 2017 by nxrighthere 0
Open

URP - HDRP SUPPORT ?

Best and simple solution for performant global illumination for standard pipeline! but none for new pipelines. Do you plan make for URP and HDRP ? both of have deferred rendering.

opened Apr 10, 2022 by AdilcanTopuz 3
Open

List of bugs and potential performance improvements

Hi Cody,

first of all, I'd like to thank you for giving away such an awesome piece of software for free. We are using it in the latest version of Crowfall. It works much much better than I anticipated.

However, while I was integrating it, I found few things that could be improved, especially performance-wise:

You don't need flip-flopping volume textures because you are writing to integerVolume but you are reading from volumeTexture[]. So you can get rid of the volumeTextureB render texture as well as the voxelFlipFlop and activeVolume variables.

Also you can skip creating secondaryIrradianceVolume when infiniteBounces is disabled. These two changes alone will halve the VRAM requirement from about 512 MB to about 256 MB.

The previousActiveVolume at SEGI.cs:154 is passed to the transferIntsCompute shader, but the shader doesn't use it. So you can rid of it.

This line in SEGI.cs doesn't do anything since DepthTextureMode.Node == 0. You probably meant to write "=" instead of "|=":

shadowCam.depthTextureMode |= DepthTextureMode.None;

This line in SEGI.cs will throw a NullRef if sun hasn't been assigned. You are checking for null in other places but not here:

Vector3 shadowCamPosition = voxelSpaceOrigin + Vector3.Normalize(-sun.transform.forward) * shadowSpaceSize * 0.5f * shadowSpaceDepthRatio;

Your VRAM calculation for the sun depth texture isn't correct, since you are creating both a color and depth buffer:

v += sunDepthTextures[i].width * sunDepthTextures[i].height * 16;		// should have been 16 bits for the rhalf color and 16 bits for the depth

You could create a depth-buffer-only texture like this to save some VRAM

new RenderTexture(sunShadowResolution, sunShadowResolution, 16, RenderTextureFormat.Depth, RenderTextureReadWrite.Linear);

(use RenderTextureFormat.Depth instead of RHalf) but it would require some additional changes (see below).

CleanupTexture is missing a texture.Release(); A null check would make things easier as well. You are also still destroying textures manually in many places instead of calling this function.

This line at SEGI.cs:827 is not being used. I think, it also should have been voxelSpaceSize / voxelResolution:

float voxelTexel = (1.0f * voxelSpaceSize) / (int)voxelResolution * 0.5f;			//Calculate the size of a voxel texel in world-space units

Not a bug but this line (SEGI.cs:380)

int resolution = (int)voxelResolution / Mathf.RoundToInt(Mathf.Pow((float)2, (float)i));

can be written much simpler as

int resolution = (int)voxelResolution >> i;

Similarily, the line 975 could be simplified to

int destinationRes = (int)voxelResolution >> (i + 1);

notReadyToRender is never set to true anywhere.

I didn't understand initChecker = new object() (SEGI.cs:620). Couldn't you have simply used a bool and avoided the memory allocation?

Cache all shader parameter ids with Shader.PropertyToID to avoid a string-to-id conversion with every call:

// Shader.SetGlobalTexture("SEGIVolumeTexture1", secondaryIrradianceVolume);
static readonly int _SEGIVolumeTexture1Id = Shader.PropertyToID("SEGIVolumeTexture1");
Shader.SetGlobalTexture(_SEGIVolumeTexture1Id, secondaryIrradianceVolume);

Also avoid run-time memory allocations due to string concatenation like here

// Shader.SetGlobalTexture("SEGIVolumeLevel" + i.ToString(), clipmaps[i].volumeTexture0);
Shader.SetGlobalTexture(IDs.SEGIVolumeLevel[i + 1], volumeTextures[i + 1]);

When you are creating the voxelCamera in line 556, you should also set aspectRatio to 1. The reason is that you are only specifying the vertical orthographic size. The horizontal orthographic size is calculated from the aspect ratio which is the screen aspect ratio or the target texture aspect ratio. You are not assigning a target texture until line 949, so the projection matrix in line 883 is actually wrong for the first frame. Alternatively, you could also assign the target texture when creating the camera.

At SEGI.cs line 293

Shader.SetGlobalColor(IDs.GISunColor, new Color(Mathf.Pow(sunColor.r, 2.2f), Mathf.Pow(sunColor.g, 2.2f), Mathf.Pow(sunColor.b, 2.2f), Mathf.Pow(sunIntensity, 2.2f)));
Shader.SetGlobalColor(IDs.SEGISkyColor, new Color(Mathf.Pow(skyColor.r * skyIntensity * 0.5f, 2.2f), Mathf.Pow(skyColor.g * skyIntensity * 0.5f, 2.2f), Mathf.Pow(skyColor.b * skyIntensity * 0.5f, 2.2f), Mathf.Pow(skyColor.a, 2.2f)));

As you know, you do have to linearize colors that you pass to shaders when you are using linear workflow (see PlayerSettings.Player.ColorSpace). MaterialPropertyBlock.SetColor and Material.SetColor do this automatically for you but Shader.SetGlobalColor doesn't. So it is correct that you are doing it manually here. Usually, when linearizing, you don't want to modify the alpha value. This is exactly what Color.linear is doing. I don't think sunIntensity should be linearized, so you can simplify this code by calling Color.linear. A non-linear sun intensity makes GI become very faint when sun intensity is less than 1 because a value less than 1 to the power of 2.2 becomes a very small value.

Shader.SetGlobalColor(IDs.GISunColor, new Color(sunColor.r, sunColor.g, sunColor.b, sunIntensity).linear);
Shader.SetGlobalColor(IDs.SEGISkyColor, new Color(skyColor.r * skyIntensity, skyColor.g * skyIntensity, skyColor.b * skyIntensity, skyColor.a).linear);

voxelToGIProjection at SEGI.cs line 888 is calculated before the shadowCam position and orientation is set:

Matrix4x4 voxelToGIProjection = (shadowCam.projectionMatrix) * (shadowCam.worldToCameraMatrix) * (voxelCamera.cameraToWorldMatrix);
Shader.SetGlobalMatrix("SEGIVoxelToGIProjection", voxelToGIProjection);

...

//Render the depth texture from the sun's perspective in order to inject sunlight with shadows during voxelization
if (sun != null)
{
	shadowCam.cullingMask = giCullingMask;

	Vector3 shadowCamPosition = voxelSpaceOrigin + Vector3.Normalize(-sun.transform.forward) * shadowSpaceSize * 0.5f * shadowSpaceDepthRatio;

	shadowCamTransform.position = shadowCamPosition;
	shadowCamTransform.LookAt(voxelSpaceOrigin, Vector3.up);

For line 287 in SEGIVoxelizeScene

float4 shadowPos = mul(SEGIVoxelProjectionInverse, float4(fcoord * 2.0 - 1.0, 0.0));

w should be 1, I think. You are transforming a point, not a vector. That's probably also the reason why you need such a high bias here

float sunVisibility = saturate((sunDepth - shadowPos.z + 0.2525) * 1000.0);  // you can use 0.001 instead of 0.2525 if you change w to 1

Using 1 for w also allows you to combine the two matrices and save an expensive matrix multiplication in the pixel shader.

At SEGI.shader line 114, you are calculating sin(asin(latitude)). You can also use trigonometric identities and the sincos function to reduce the number of expensive transcendentals. Instead of

float latitude = asin(fiN * 2.0 - 1.0);

float3 kernel;
kernel.x = cos(latitude) * cos(longitude);
kernel.z = cos(latitude) * sin(longitude);
kernel.y = sinLatitude);

you can write

float longitude = gAngle * fi;

float sinLatitude = fiN * 2.0 - 1.0;
float cosLatitude = sqrt(1.0 - sinLatitude * sinLatitude);
float sinLongitude, cosLongitude;
sincos(longitude, sinLongitude, cosLongitude);

float3 kernel;
kernel.x = cosLatitude * cosLongitude;
kernel.z = cosLatitude * sinLongitude;
kernel.y = sinLatitude;

I hope the compiler optimizes these but I wouldn't rely on it: SEGI.shader line 81: float3 viewVector = normalize(viewSpacePosition.xyz); // unused SEGI.shader line 121: kernel = normalize(kernel + worldNormal.xyz * 1.0); // times 1 SEGI.shader line 213: int HalfResolution; // unused SEGI.shader line 223: float3 albedo = albedoTex.rgb; // unused SEGI.shader line 465: float3 albedo = albedoTex.rgb; // unused SEGI.cginc line 27-31:

sampler3D SEGIVolumeLevel6;  // unused
sampler3D SEGIVolumeLevel7;  // unused
sampler3D VolumeTexture1;  // unused
sampler3D VolumeTexture2;  // unused
sampler3D VolumeTexture3;  // unused

SEGI.cginc line 117: coneDistance -= 0.00; SEGI.cginc line 143: float falloffFix = pow(fi, 1.0) * 4.0 + NearLightGain; // pow(fi, 1) = fi SEGITraceScene.shader line 34-35:

sampler3D SEGIVolumeLevel6;	// unused
sampler3D SEGIVolumeLevel7;	// unused

SEGITraceScene.shader line 156: float4x4 SEGIVoxelToGIProjection; // unused SEGITransferInts.compute line 5: Texture3D<float4> PrevResult; // unused SEGITransferInts.compute line 14: float4 VoxelOriginDelta; // unused SEGIVoxelizeScene.shader line 8: _Cutoff ("Alpha Cutoff", Range(0,1)) = 0.333 // unused SEGIVoxelizeScene.shader line 28: int LayerToVisualize; // unused SEGIVoxelizeScene.shader line 70: float3 absNormal = abs(o.normal); // unused SEGIVoxelizeScene.shader line 320: const float sqrt2 = sqrt(2.0) * 1.0; // times 1 is superflous. Also, I'd just hardcode the constant. Not sure if the compiler is smart enough to precalculate the value.

In SEGI.cginc VisualConeTrace:

float4 sample = tex3Dlod(SEGIVolumeLevel0, float4(voxelCheckCoord.xyz, coneSize));

SEGIVolumeLevel0 doesn't have mips, so it's pointless to calculate coneSize. Also, I would simply stop at the first opaque voxel instead of using voxel cone tracing. It also helps to add a small constant brightness so that voxels that don't get any light are not completely black. I'm aware that this is just used for debugging, though.

I've tried converting the if-cascade at line 125 to a switch in the hope that it can be optimized with a jump table but it turned out that UNITY_BRANCH switch(mipLevel) becomes an if-cascade anyways.

In SEGIMipFilter.compute:

for (int i = 0; i < destinationRes; i++)
{
	float3 fcoord = float3((float)id.x / destinationRes, (float)id.y / destinationRes, (float)i / destinationRes);
	float texel = 1.0 / destinationRes;
	...
}

Calculate the inverse of the destinationRes outside of the loop (or even better, pass a uniform with the inverse). Just move the texel calculation outside of the loop.

In CSMainGaussian:

int c = 0;

for (int j = 0; j < 8; j++)
{
	float3 offset = float3(0, 0, 0);

	offset = offsets[j];

	tex += Source.SampleLevel(_LinearClamp, fcoord + texel * 0.5 + offset * texel * 0.5, 0.0);
	c++;
}

tex /= c;

c will always be 8, so simply multiply tex by 0.125.

At SEGITraceScene.shader line 186:

for (int i = 0; i < numSteps; i++)
{
	float fi = ((float)i) / numSteps;

Calculate the inverse outside of the loop and multiply with the reciprocal (multiplications are way cheaper than division).

At SEGITraceScene.shader line 195:

if (mipLevel == 0)
	sample = tex3Dlod(SEGIVolumeLevel1, float4(voxelCheckCoord.xyz, coneSize));

Miplevel 0 is sampling from SEGIVolumeLevel1 instead of SEGIVolumeLevel0. This could be intentional, but I thought, I'll point it out in case it isn't.

In SEGIVoxelizeScene.shader line 302, skip the texture lookup when emission color is black:

float4 emissionTex = tex2D(_EmissionMap, input.uv.xy);

Texture lookups are the most expensive things you can do in a shader so you can use dynamic branching to skip it, since very few voxels are actually emissive:

float emissionTex = 0.0;
UNITY_BRANCH
if (dot(_EmissionColor.rgb, _EmissionColor.rgb) == 0.0)
	emissionTex = tex2D(_EmissionMap, input.uv.xy);

Same for sampling the volume texture when infiniteBounces are off (line 314):

float4 prevBounce = tex3D(SEGIVolumeTexture1, fcoord + SEGIVoxelSpaceOriginDelta.xyz);
col.rgb += prevBounce.rgb * 1.6 * SEGISecondaryBounceGain * tex.rgb * color.rgb;

becomes

UNITY_BRANCH
if (SEGISecondaryBounceGain > 0)
{
	float4 prevBounce = tex3D(SEGIVolumeTexture1, fcoord + SEGIVoxelSpaceOriginDelta.xyz);
	col.rgb += prevBounce.rgb * 1.6 * SEGISecondaryBounceGain * tex.rgb * color.rgb;
}

You could also premultiply GISunColor.rgb by GISunColor.a and _EmissionColor.rgb * 0.9 (line 312) on the CPU, but that will probably not make a noticeable difference.

SEGIVoxelizeScene.shader line 260:

#define VoxelResolution (SEGIVoxelResolution * (1 + SEGIVoxelAA))

Not sure why this is a define. Just make it a variable so that it's only calculated once.

SEGIVoxelizeScene.shader line 89:

void geom(triangle v2g input[3], inout TriangleStream<g2f> triStream)
{
	v2g p[3];
	for (int i = 0; i < 3; i++)
	{
		p[i] = input[i];
		p[i].pos = mul(unity_ObjectToWorld, p[i].pos);						
	}

You can move the matrix multiplication to the vertex shader. No need to do it more than once per vertex.

There are a few problems with shadow map rendering, but it's not easy to fix, unfortunately:

shadowCam.RenderWithShader(sunDepthShader, "");

First of all, this manually renders depth to a color target AND a depth buffer. You only need the depth buffer, but it's not easy to do that. I think, you could use a temporary render target for the depth at least - instead of creating sunDepthTexture with both a color and depth. Another problem is, shader overrides like this don't work with shaders that modify the vertex in the vertex shader or have a geometry shader. The correct way would be to render the shadow map with the shadow pass of the original shaders - but you have to make individual draw calls to do that. The advantage of that is that you can also get rid of the sunDepthShader. This also doesn't take the ShadowCastingMode of the mesh renderers into account.

However, as you are aware - I'm sure - the biggest performance problem is rendering the shadow cam and the voxel cam every frame. This will triple the draw calls. You can update them less often but it's not a good solution:

  • You'd still get hitches every couple of frames
  • Since you are no longer rendering every frame, you can't render just what's in front of the camera. So you have to center the voxel space around the camera which reduces the voxel space distance.

We used time-sliced rendering for both the voxel space camera and the shadow camera. All the renderers register themselves into a grid and only one grid cell is being rendered at a time. We also separated shadow rendering and voxel rendering by double-buffering the shadow map. This means, it will take about a second until all the grid cells around the camera have been updated but it's much more performant. This might not work for every game because you have to exclude dynamic objects from contributing GI that are moving fast (like characters) but you can still have dynamic time of day and slow moving objects (dynamic destruction, doors, falling trees, etc.).

We also used half the vertical voxel space resolution so that we could increase the horizontal resolution. But this only makes sense for exteriors where you have a long view distance.

Finally, we also added support for point lights - which was not very hard since we already had a grid that could give us a list of lights for a given cell.

It really surprised me that voxel based GI can work that well in an open-world game. The voxels are huge but it doesn't matter really. You can get a few light leaks if you make them too big but it's barely worth mentioning. Also the reflections look amazing. Temporal stability is great as well.

Anyways, keep up the good work and thank you again for making SEGI available to everyone!

Georg Principal Engineer at Monumental

opened Mar 1, 2022 by george-monumental 4
Open

Is there a simple way to improve the voxel resolution?

Hi,sonicether.This addon is amazing. I found in SEGI.cs, the high setting is 256.I have tried to increase the number to 512 or more.But the result doesn't change.

public enum VoxelResolution
{
	low = 128,
	high = 256
}

May i ask what i should do?Do i need to modify other related code at the same time?Thanks

opened Nov 21, 2019 by Wenzy-- 1
Open

Shadow issue with Skinned Mesh Renderer

Hi, i was setting my scene up with SEGI when i realised that i had really strange shadow issues with Ethan (and every other mesh renderer). The size of the circles you can see on the following gif is changing depending of the Voxel space size. here is the result at 30, the only way to have a descent shadow is having the value between 5 or 7.

Any idea of what coul be this strange shadow and how to avoid it ?

I'm on Unity 2018.1.5f1 btw

https://gfycat.com/LikelyIndelibleGourami

opened Aug 23, 2018 by PhoenixOf77 0
Open

Error: Dimensions of color surface does not match dimensions of depth surface, with Unity 2018

Dimensions of color surface does not match dimensions of depth surface UnityEngine.Camera:RenderWithShader(Shader, String) SEGICascaded:OnPreRender() (at Assets/SEGI/SEGICascaded.cs:1097)

opened Jun 3, 2018 by ninlilizi 1
Open

Help; Required To Port SEGI to HD SRP

Hey, With the HD SRP around the corner and having checked it out myself. Unity is moving closer to photorealism. and closer to Unreal like graphics .

And our current project is making heavy use of SEGI . I opneded up the SEGI and shader script. It seemed pretty straight forward at first. But I am having trouble to see where you are acessing Unity Standard shader "_MainTex,_Albedo" and what not

I was wondering if you could provide us on an insight on how I could go around port in to HD SRP
Just some API example wher I can modify the texture being sampled and maybe the render Passes

Thanks a ton :)

opened Mar 23, 2018 by deltamish 9

Contents

    compix Global illumination with Voxel Cone Tracing in fully dynamic scenes using a 3D clipmap to support huge areas around the camera while maintaining a low memory footprint.
    Looooong Voxel-based Global Illumination using Unity Scriptable Render Pipeline
    Friduric A real-time global illumination implementation using voxel cone tracing. Implemented in C++ and GLSL.
    kbladin Converting vertex meshes to voxel data and visualizing using VCT
    rdinse GPU-based real-time global illumination renderer based on voxel cone tracing
    bloc97 Exploratory Project on Fast Screen Space Global Illumination
    djiajunustc Voxel R-CNN: Towards High Performance Voxel-based 3D Object Detection
    ninlilizi A fully-dynamic voxel-based global illumination system for Unity.
    jose-villegas Deferred Voxel Shading for Real Time Global Illumination
    demonixis Screen Space Global Illumination for Unity Universal Render Pipeline
    XT95 Point Based Global Illumination
    zero-radiance Tiny Global Illumination OpenGL Renderer
    samuelbigos 2D Global Illumination shader in Godot.
    EKnapik A comparison of typical real-time and offline illumination methods. (SSAO, HBO, VXGI, and Ray Traced Global Illumination)
    thefranke A mixed reality testing environment for real-time global illumination algorithms
    djbozkosz Master's thesis implementing real-time global illumination method.
    cache-tlb Some (simple) global illumination algorithms
    DavidWilliams81 Cubiquity is an experimental micro-voxel engine written in C++ and released into the public domain.
    groverburger Simple and efficient voxel engine for LÖVE using g3d
    3huo 3DV: 3D Dynamic Voxel for Action recognition in depth video.
    Microsoft The Xbox Live Unity Plugin provides a way for developers in the Xbox Live Creators Program to quickly and easily integrate Xbox Live functionality into their Unity based game. For ID@Xbox developers, this Xbox Live Unity Plugin does not yet support all the features you will need. Instead, contact your Microsoft representative.
    Share this repo

    Related Repos


    Game
    21
    FirstPerson mod for the game Townscaper
    DigitalzombieTLD Townscaper - LittleFirstPerson mod - v0.8.0 by Digitalzombie =========================================================== How to install: ============
     
    Game
    256
    Open source mesh slicing/fracturing utility for Unity
    dgreenheck OpenFracture OpenFracture is an open source Unity package for fracturing & slicing meshes. This package supports both convex and non-convex meshes as
     
    Game
    4
    Star Wars inspired hologram system for Unity
    rectdev Sologram Star Wars inspired hologram system for Unity. Sologram is composed of two components. the Sologram Renderer and the Sologram Object. Sologram
     
    Game
    3
    A simple library of visual elements to be used for graphs and charts when using the new ru...
    PaoloAtRebelpug rebelpug-unity-ui-toolkit-graphs-and-charts A simple library of visual elements to be used for graphs and charts when using the new runtime UI Toolkit
     
    Game
    23
    Small Unity editor extension that allows you to automatically select interface implementat...
    Juce-Assets Welcome to Implementation Selector Welcome to Implementation Selector: a small Unity editor extension that allows you to automatically select an inter
     
    Game
    4
    Bits and pieces for Unity Engine in C# by yours truly.
    SoftwareGuy Unity-Bits-And-Pieces Bits and pieces for Unity Engine in C# by yours truly. Licensing Warning The code in this repository, unless otherwise stated, i
     
    Game
    3
    Dump for Standoff 2 game
    Oifox Standoff-2-Dump Dump for Standoff 2 game Repository have 2 dump folders. The first is a dump with deobfuscated methods, and the second is a dump of th
     
    Game
    157
    Multi-functional shader for the Particle System that supports Universal Render Pipeline (U...
    CyberAgentGameEntertainment NOVA Shader: Uber shader for Particle System Docs (English, 日本語) | Samples (English, 日本語) | Demo (English, 日本語) NOVA Shader is a multi-functional shad
     
    Game
    4
    Volumetric Lighting in URP
    voxell-tech URP Volumetric Lighting This package's goal is to provide full volumetric solution for the Universal Render Pipeline. Currently, it only supports Volu
     
    Game
    6
    Proof of concept wrapper to allow using Unity Physics directly with Game Objects (without ...
    IronWarrior This repository demonstrates how to directly interact with Unity Physics without using Unity's Entity Component System (ECS)†. 2021-12-05.12-06-13.mp4
     
    Game
    15
    Unity Timeline extensions for Bibcam
    keijiro BibcamTimeline BibcamTimeline is an extension for Unity Timeline that adds Bibcam video clip support. At the moment, it only supports HAP-encoded Bibc
     
    Game
    7
    A library for making UI-driven plugins which target IL2CPP and Mono Unity games.
    sinai-dev UniverseLib Library used by UnityExplorer, BepInExConfigManager and MelonPreferencesManager. Contains common implementations for creating UI-driven pl
     
    Game
    3.5k
    Stride Game Engine (formerly Xenko)
    stride3d Welcome to the Stride source code repository! Stride is an open-source C# game engine for realistic rendering and VR. The engine is highly modular and
     
    Game
    1.2k
    A fully-dynamic voxel-based global illumination system for Unity
    sonicether SEGI A fully-dynamic voxel-based global illumination system for Unity. More details at http://www.sonicether.com/segi/ Installation Check the Releases
     
    Game
    3
    A platformer where the entire world bends like a worm
    Bauxitedev BENDYWORM is a platformer with a twist: the entire world bends and twists around you as your progress through the level. Why? Because you're inside of