Difference between revisions of "GPU Instancer"

From GurBu Wiki
Jump to: navigation, search
Line 11: Line 11:
  
 
---------------------------------
 
---------------------------------
Features
+
'''Features'''
 
---------------------------------
 
---------------------------------
- Out of the box solution for complex GPU Instancing.
 
  
- VR compatible. Works with both single pass and multipass rendering modes.
 
  
- Mobile compatible. Works with both iOS and Android.
+
* Out of the box solution for complex GPU Instancing.
  
- Easy to use interface.
+
* VR compatible. Works with both single pass and multipass rendering modes.
  
- Tens of thousands of objects rendered lightning fast in a single draw call.
+
* Mobile compatible. Works with both iOS and Android.
  
- GPU frustum culling.
+
* Easy to use interface.
  
- GPU occlusion culling (non-VR platforms only).
+
* Tens of thousands of objects rendered lightning fast in a single draw call.
  
- Automatically configured custom shader support.
+
* GPU frustum culling.
  
- Supports HDRP and LWRP render pipelines.
+
* GPU occlusion culling (non-VR platforms only).
  
- Complex hierarchies of prefabs instanced with a single click.
+
* Automatically configured custom shader support.
  
- Multiple sub-meshes support.
+
* Supports HDRP and LWRP render pipelines.
  
- LOD Groups and cross-fading support (with animation or fade transition width).
+
* Complex hierarchies of prefabs instanced with a single click.
  
- [[GPU_Instancer:Features#Automatic_2D_Billboard_Generation_System|Automatic 2D Billboard Generation System (Auto-added as Last LOD)]].
+
* Multiple sub-meshes support.
  
- Shadows casting and receiving support for instances (frustum culled instances still can cast shadows).
+
* LOD Groups and cross-fading support (with animation or fade transition width).
  
- Ability to use custom shadow distance per prototype and to choose the LOD to render shadows with.
+
* [[GPU_Instancer:Features#Automatic_2D_Billboard_Generation_System|Automatic 2D Billboard Generation System (Auto-added as Last LOD)]].
  
- Unity 5.6 support.
+
* Shadows casting and receiving support for instances (frustum culled instances still can cast shadows).
  
- Well documented API for procedural scenes and runtime modifications (examples included).
+
* Ability to use custom shadow distance per prototype and to choose the LOD to render shadows with.
  
- Ability to Remove instances inside bounds or colliders at runtime.
+
* Unity 5.6 support.
  
- Ability to extend with custom Compute Shaders.
+
* Well documented API for procedural scenes and runtime modifications (examples included).
  
- Example scenes that showcase GPU Instancer capabilities.
+
* Ability to Remove instances inside bounds or colliders at runtime.
  
 +
* Ability to extend with custom Compute Shaders.
  
Prefab Instancing Features:
+
* Example scenes that showcase GPU Instancer capabilities.
  
- Ability to automatically instance prefabs at your scene that you distribute with your favorite prefab painting tool.
 
  
- [[GPU_Instancer:Features#Automatically_Add-Remove_prefab_instances_without_any_aditional_code|Automatically Add-Remove prefab instances without any aditional code]].
+
'''Prefab Instancing Features:'''
  
- Automatic detection and updating of transform position, rotation and scale changes.
+
* Ability to automatically instance prefabs at your scene that you distribute with your favorite prefab painting tool.
  
- Full or area localized rigidbody and physics support.
+
* [[GPU_Instancer:Features#Automatically_Add-Remove_prefab_instances_without_any_aditional_code|Automatically Add-Remove prefab instances without any aditional code]].
  
- [[GPU_Instancer:Features#Nested_Prefabs_support_.28Unity_2018.3_and_later.29|Nested Prefabs support (Unity 2018.3 and later)]].
+
* Automatic detection and updating of transform position, rotation and scale changes.
  
- [[GPU_Instancer:Features#Add-Remove-Update_prefab_instances_with_or_without_instantiating_GameObjects|Add-Remove-Update prefab instances with or without instantiating GameObjects (examples included)]].
+
* Full or area localized rigidbody and physics support.
  
- Instance based material variations through API (similar to Material Property Blocks).
+
* [[GPU_Instancer:Features#Nested_Prefabs_support_.28Unity_2018.3_and_later.29|Nested Prefabs support (Unity 2018.3 and later)]].
  
- Enabling and disabling instancing at runtime per instance basis.
+
* [[GPU_Instancer:Features#Add-Remove-Update_prefab_instances_with_or_without_instantiating_GameObjects|Add-Remove-Update prefab instances with or without instantiating GameObjects (examples included)]].
  
- API to manage instanced prefabs at runtime.
+
* Instance based material variations through API (similar to Material Property Blocks).
  
- Includes mobile demo scene with custom controllers.
+
* Enabling and disabling instancing at runtime per instance basis.
  
 +
* API to manage instanced prefabs at runtime.
  
Detail Instancing Features:
+
* Includes mobile demo scene with custom controllers.
  
- Dense grass fields and vegetation with very high frame rates.
 
  
- Included vegetation shader with wind, shadows, AO, billboarding and various other properties.
+
'''Detail Instancing Features:'''
  
- Support for custom shaders and materials.
+
* Dense grass fields and vegetation with very high frame rates.
  
- Cross quadding support: automatically turns grass textures to crossed quads.
+
* Included vegetation shader with wind, shadows, AO, billboarding and various other properties.
  
- Ability to paint prefabs with custom materials on Unity terrain (with Unity terrain tools).
+
* Support for custom shaders and materials.
  
- Ability to use prefabs with LOD Groups on Unity terrain.
+
* Cross quadding support: automatically turns grass textures to crossed quads.
  
- Further performance improvements with automatic spatial partitioning.
+
* Ability to paint prefabs with custom materials on Unity terrain (with Unity terrain tools).
  
- API to manage instanced terrain detail prototypes at runtime (examples included).
+
* Ability to use prefabs with LOD Groups on Unity terrain.
  
- Editor GPU Instancing simulation.
+
* Further performance improvements with automatic spatial partitioning.
  
 +
* API to manage instanced terrain detail prototypes at runtime (examples included).
  
Tree Instancing Features:
+
* Editor GPU Instancing simulation.
  
- Dense forests with very high frame rates.
 
  
- Speed Tree support with wind animations.
+
'''Tree Instancing Features:'''
  
- Tree Creator support with wind animations.
+
* Dense forests with very high frame rates.
  
- Included billboard baker and renderers.
+
* Speed Tree support with wind animations.
  
- Custom vertex color wind animation support for Soft Occlusion Tree shaders.
+
* Tree Creator support with wind animations.
  
 +
* Included billboard baker and renderers.
  
Third Party Integrations:
+
* Custom vertex color wind animation support for Soft Occlusion Tree shaders.
  
- Gaia integration.
 
  
- Map Magic integration.
+
'''Third Party Integrations:'''
  
 +
* Gaia integration.
  
Planned Features:
+
* Map Magic integration.
  
- Support for animation baking and skinned mesh renderers.
 
  
 +
'''Planned Features:'''
  
Requirements:
+
* Support for animation baking and skinned mesh renderers.
  
- DirectX 11 or DirectX 12 and Shader Model 5.0 GPU (Windows, Windows Store)
 
  
- Metal (macOS, iOS)
+
'''Requirements:'''
  
- OpenGL Core 4.3 (Windows, Linux)
+
* DirectX 11 or DirectX 12 and Shader Model 5.0 GPU (Windows, Windows Store)
  
- Vulkan (Android, Windows, Linux)
+
* Metal (macOS, iOS)
  
- OpenGL ES 3.1 (Android 8.0 Oreo or later)
+
* OpenGL Core 4.3 (Windows, Linux)
  
- Modern Consoles (PS4, Xbox One)
+
* Vulkan (Android, Windows, Linux)
 +
 
 +
* OpenGL ES 3.1 (Android 8.0 Oreo or later)
 +
 
 +
* Modern Consoles (PS4, Xbox One)
  
  

Revision as of 00:43, 8 December 2018

About | Features | Getting Started | Terminology | Best Practices | F.A.Q.


GPU Instancer is an out of the box solution to display extreme numbers of objects on screen with high performance. With a few mouse clicks, you can instance your prefabs and Unity terrain details and trees.

GPU Instancer provides user friendly tools to allow everyone to use Indirect GPU Instancing without having to go through the deep learning curve of Compute Shaders and GPU infrastructure. Also, an API with extensive documentation is provided to manage runtime changes.




Features



  • Out of the box solution for complex GPU Instancing.
  • VR compatible. Works with both single pass and multipass rendering modes.
  • Mobile compatible. Works with both iOS and Android.
  • Easy to use interface.
  • Tens of thousands of objects rendered lightning fast in a single draw call.
  • GPU frustum culling.
  • GPU occlusion culling (non-VR platforms only).
  • Automatically configured custom shader support.
  • Supports HDRP and LWRP render pipelines.
  • Complex hierarchies of prefabs instanced with a single click.
  • Multiple sub-meshes support.
  • LOD Groups and cross-fading support (with animation or fade transition width).
  • Shadows casting and receiving support for instances (frustum culled instances still can cast shadows).
  • Ability to use custom shadow distance per prototype and to choose the LOD to render shadows with.
  • Unity 5.6 support.
  • Well documented API for procedural scenes and runtime modifications (examples included).
  • Ability to Remove instances inside bounds or colliders at runtime.
  • Ability to extend with custom Compute Shaders.
  • Example scenes that showcase GPU Instancer capabilities.


Prefab Instancing Features:

  • Ability to automatically instance prefabs at your scene that you distribute with your favorite prefab painting tool.
  • Automatic detection and updating of transform position, rotation and scale changes.
  • Full or area localized rigidbody and physics support.
  • Instance based material variations through API (similar to Material Property Blocks).
  • Enabling and disabling instancing at runtime per instance basis.
  • API to manage instanced prefabs at runtime.
  • Includes mobile demo scene with custom controllers.


Detail Instancing Features:

  • Dense grass fields and vegetation with very high frame rates.
  • Included vegetation shader with wind, shadows, AO, billboarding and various other properties.
  • Support for custom shaders and materials.
  • Cross quadding support: automatically turns grass textures to crossed quads.
  • Ability to paint prefabs with custom materials on Unity terrain (with Unity terrain tools).
  • Ability to use prefabs with LOD Groups on Unity terrain.
  • Further performance improvements with automatic spatial partitioning.
  • API to manage instanced terrain detail prototypes at runtime (examples included).
  • Editor GPU Instancing simulation.


Tree Instancing Features:

  • Dense forests with very high frame rates.
  • Speed Tree support with wind animations.
  • Tree Creator support with wind animations.
  • Included billboard baker and renderers.
  • Custom vertex color wind animation support for Soft Occlusion Tree shaders.


Third Party Integrations:

  • Gaia integration.
  • Map Magic integration.


Planned Features:

  • Support for animation baking and skinned mesh renderers.


Requirements:

  • DirectX 11 or DirectX 12 and Shader Model 5.0 GPU (Windows, Windows Store)
  • Metal (macOS, iOS)
  • OpenGL Core 4.3 (Windows, Linux)
  • Vulkan (Android, Windows, Linux)
  • OpenGL ES 3.1 (Android 8.0 Oreo or later)
  • Modern Consoles (PS4, Xbox One)


To provide the fastest possible performance, GPU Instancer utilizes Indirect GPU Instancing using Unity's DrawMeshInstancedIndirect method and Compute Shaders.


GPU Instancing results in magnitudes of performance improvement over static batching and mesh combining. Also, other available solutions for GPU Instancing (including Unity's material option and the DrawMeshInstanced method) fail short on limited buffer sizes and therefore result in more draw calls and less performance. By using the indirect method GPU Instancer aims to provide the ultimate solution for this, and increases performance considerably while rendering the same mesh multiple times.