Fast Fur Render Pipeline options - Revision history

Warren: /* What is a "shader pipeline"? */

2023-07-10T00:18:51Z

What is a "shader pipeline"?

← Older revision		Revision as of 17:18, 9 July 2023
Line 4:		Line 4:
	The word "shader" is used inter-changeably to describe either an entire beginning-to-end shader pipeline (ie. "Warren's Fast Fur Shader"), or to describe the various self-contained stages of the pipeline (ie. a "Vertex shader", "Geometry shader", etc...).		The word "shader" is used inter-changeably to describe either an entire beginning-to-end shader pipeline (ie. "Warren's Fast Fur Shader"), or to describe the various self-contained stages of the pipeline (ie. a "Vertex shader", "Geometry shader", etc...).

	The shader currently uses the Unity Built-in Render Pipeline (BiRP). This ~~graphics~~ pipeline consists of 4 programmable shader stages: Vertex, Hull + Domain, Geometry, and Fragment:		The shader currently uses the Unity Built-in Render Pipeline (BiRP). This GPU pipeline consists of 4 programmable shader stages: Vertex, Hull + Domain, Geometry, and Fragment:
	[[File:Unity BiRP.jpg\|none\|thumb\|640x640px\|The 4 programmable stages of the Unity BiRP. The "Hull + Domain" and "Geometry" stages are optional.]]		[[File:Unity BiRP.jpg\|none\|thumb\|640x640px\|The 4 programmable stages of the Unity BiRP. The "Hull + Domain" and "Geometry" stages are optional.]]
	Each shader stage processes the information it is given, then outputs the result. The GPU drivers are then responsible for transfering that output to the next stage, as well as performing non-programmable functions such as combining individual verticies into triangles, or trimming triangles that are only partially on-screen.		Each shader stage processes the information it is given, then outputs the result. The GPU drivers are then responsible for transfering that output to the next stage, as well as performing non-programmable functions such as combining individual verticies into triangles, or trimming triangles that are only partially on-screen.

Warren: /* What is a "shader"? */

2023-07-10T00:18:03Z

What is a "shader"?

← Older revision		Revision as of 17:18, 9 July 2023
Line 1:		Line 1:
	== What is a "shader"? ==		== What is a "shader pipeline"? ==
	GPU programs (ie. "shaders") aren't like regular programs. They run on the GPU, not the CPU. They are also massively parrallel, running hundreds or even thousands of copies of themselves at the same time.		GPU programs (ie. "shaders") aren't like regular programs. They run on the GPU, not the CPU. They are also massively parrallel, running hundreds or even thousands of copies of themselves at the same time.

Warren: Added an intro section

2023-07-10T00:17:52Z

Added an intro section

← Older revision		Revision as of 17:17, 9 July 2023
Line 1:		Line 1:
	The shader currently uses the Unity Built-in Render Pipeline (BiRP). This graphics pipeline consists of 4 programmable shader stages: Vertex, Hull+Domain, Geometry, and Fragment.		== What is a "shader"? ==
			GPU programs (ie. "shaders") aren't like regular programs. They run on the GPU, not the CPU. They are also massively parrallel, running hundreds or even thousands of copies of themselves at the same time.

			The word "shader" is used inter-changeably to describe either an entire beginning-to-end shader pipeline (ie. "Warren's Fast Fur Shader"), or to describe the various self-contained stages of the pipeline (ie. a "Vertex shader", "Geometry shader", etc...).

			The shader currently uses the Unity Built-in Render Pipeline (BiRP). This graphics pipeline consists of 4 programmable shader stages: Vertex, Hull + Domain, Geometry, and Fragment:
			[[File:Unity BiRP.jpg\|none\|thumb\|640x640px\|The 4 programmable stages of the Unity BiRP. The "Hull + Domain" and "Geometry" stages are optional.]]
			Each shader stage processes the information it is given, then outputs the result. The GPU drivers are then responsible for transfering that output to the next stage, as well as performing non-programmable functions such as combining individual verticies into triangles, or trimming triangles that are only partially on-screen.

	''(NOTE: The shader does not currently support Unity's other render pipelines, namely the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and Scriptable Render Pipeline (SRP). Future support for these pipelines is planned, but not until the shader is more polished, reliable, and feature-complete.)''		''(NOTE: The shader does not currently support Unity's other render pipelines, namely the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and Scriptable Render Pipeline (SRP). Future support for these pipelines is planned, but not until the shader is more polished, reliable, and feature-complete.)''
Line 23:		Line 30:
	Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''However, the Turbo Pipeline does '''not''' use them for tesselation.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer, and discarding the rest.		Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''However, the Turbo Pipeline does '''not''' use them for tesselation.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer, and discarding the rest.

	Because even discarding triangles still takes some time, selecting a higher maximum layer limit comes with a performace hit, even when less layers are being rendered. However, this hit is relatively moderate (around 5% going from 24 to 32 layers).		Because even discarding triangles still takes some time, selecting a higher maximum layer limit comes with a performace hit, even when less layers are being rendered. However, this hit is relatively moderate (around 5% going from 24 to 32 layers), and less than the Fallback Pipeline.

	'''''The Turbo Pipeline is the recommended pipeline.'''''		'''''The Turbo Pipeline is the recommended pipeline.'''''
Line 33:		Line 40:
	The Super Pipeline is typically 30% faster than the Turbo Pipeline when rendering at the same quality (ie. up to 32 layers), but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264(!) layers of fur.		The Super Pipeline is typically 30% faster than the Turbo Pipeline when rendering at the same quality (ie. up to 32 layers), but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264(!) layers of fur.

	The Super Pipeline's speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that un-needed triangles do not need to be discarded, because they are never created in the first place.		The Super Pipeline's speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed (note: this is not tesselation, since it is only making copies of the triangles, not sub-dividing them). This means that un-needed triangles do not need to be discarded, because they are never created in the first place.

	Since the Super Pipeline doesn't need to discard triangles, there is no performance hit for having a higher layer limit. The Super Pipeline will, however, limit its maximum layers dynamically, according to the quality settings.		Since the Super Pipeline doesn't need to discard triangles, there is no performance hit for having a higher layer limit. The Super Pipeline will, however, limit its maximum layers dynamically, according to the quality settings.

	Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 6600xt, 6700xt, and 6800xt have all been confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be due to a driver bug with nested arrays, which was fixed by modifying the shader code to access the arrays using a different method. However, the other AMD GPUs appear to be crashing due to memory corruption, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the ~~Vertex~~ shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically these GPUs will lockup after about ~10 seconds.		Offloading most of the triangle copying workload to the Hull + Domain shaders from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 6600xt, 6700xt, and 6800xt have all been confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be due to a driver bug with nested arrays, which was fixed by modifying the shader code to access the arrays using a different method. However, the other AMD GPUs appear to be crashing due to memory corruption, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Hull shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically these GPUs will lockup after about ~10 seconds.

	Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.		Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.

	'''''The Super Pipeline must NEVER be used in public games!'''''		'''''The Super Pipeline must NEVER be used in public games!'''''

Warren at 22:53, 9 July 2023

2023-07-09T22:53:41Z

Warren at 22:42, 9 July 2023

2023-07-09T22:42:33Z

← Older revision		Revision as of 15:42, 9 July 2023
Line 1:		Line 1:
	~~WFFS~~ currently uses the Unity Built-in Render Pipeline (BiRP). This graphics pipeline consists of 4 programmable shader stages: Vertex, Hull+Domain, Geometry, and Fragment.		The shader currently uses the Unity Built-in Render Pipeline (BiRP). This graphics pipeline consists of 4 programmable shader stages: Vertex, Hull+Domain, Geometry, and Fragment.

	''(NOTE: ~~WFFS~~ does not currently support Unity's other render pipelines, namely the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and Scriptable Render Pipeline (SRP). Future support for these pipelines is planned, but not until the shader is more polished, reliable, and feature-complete.)''		''(NOTE: The shader does not currently support Unity's other render pipelines, namely the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and Scriptable Render Pipeline (SRP). Future support for these pipelines is planned, but not until the shader is more polished, reliable, and feature-complete.)''

	~~WFFS has 2~~ options ~~(not including the experimental Super Pipeline)~~ for how it will use the available BiRP stages:		There are 3 different options for how the shader will use the available BiRP stages:

	== Fallback Pipeline (Slow) ==		== Fallback Pipeline (Slow) ==

Warren: /* Experimental Beta Version Only: Super Pipeline (Fastest, but not usable on some AMD GPUs) */

2023-07-09T03:09:43Z

Experimental Beta Version Only: Super Pipeline (Fastest, but not usable on some AMD GPUs)

← Older revision		Revision as of 20:09, 8 July 2023
Line 10:		Line 10:

	Its lower performance is because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory, and they must reserve enough memory in advance for all possible output triangles, even if they later discard them. Any triangle that is too far away, or is backwards-facing, or is outside the visible screen area will still take time to be discarded by the Geometry shader.		Its lower performance is because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory, and they must reserve enough memory in advance for all possible output triangles, even if they later discard them. Any triangle that is too far away, or is backwards-facing, or is outside the visible screen area will still take time to be discarded by the Geometry shader.

			Because even discarding triangles still takes some time, selecting a higher maximum layer limit than 16 comes with a performace hit, even when less layers are being rendered.

	'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. This is because it doesn't use Hull + Domain shaders, which may not be supported with some games.		'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. This is because it doesn't use Hull + Domain shaders, which may not be supported with some games.
Line 15:		Line 17:
	== Turbo Pipeline (Fast) ==		== Turbo Pipeline (Fast) ==
	[[File:Turbo Pipeline.jpg\|none\|thumb\|The Turbo pipeline uses fast Hull + Domain shaders to discard most non-visible fur.]]		[[File:Turbo Pipeline.jpg\|none\|thumb\|The Turbo pipeline uses fast Hull + Domain shaders to discard most non-visible fur.]]
	Depending on view range, the Turbo Pipeline is typically 25% to 100% faster than the Fallback Pipeline, despite also having much higher quality. It can render up to 32 layers of fur.		Depending on view range, the Turbo Pipeline is typically 25% to 100% faster than the Fallback Pipeline, despite also having much higher quality. It can render up to 32 layers of fur. Selecting a higher maximum layer limit comes with a performace hit, even when less layers are being rendered.

	This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages. This prevents the relatively slow Geometry shaders from loading into GPU memory if they aren't needed.		This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages. This prevents the relatively slow Geometry shaders from loading into GPU memory if they aren't needed.

	Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''The Turbo Pipeline does not use them for tesselation, though.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer, and discarding the rest.		Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''The Turbo Pipeline does not use them for tesselation, though.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer, and discarding the rest.

			Because even discarding triangles still takes some time, selecting a higher maximum layer limit than 16 comes with a performace hit, even when less layers are being rendered. However, this hit is not as severe as with the Fallback Pipeline.

	The Turbo Pipeline is the recommended pipeline.		The Turbo Pipeline is the recommended pipeline.

	== ~~Experimental Beta Version Only:~~ Super Pipeline (Fastest, but not usable on some AMD GPUs) ==		== Super Pipeline (Fastest, capable of extremely high resolution, but not usable on some AMD GPUs) ==
	[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]		[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]
	The Super Pipeline is typically 30% faster than the Turbo Pipeline, but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.		'''The Super Pipeline is NOT available for public use, due to AMD crashing issues.'''

			The Super Pipeline is typically 30% faster than the Turbo Pipeline when rendering at the same quality (ie. up to 32 layers), but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.

			The Super Pipeline's speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that un-needed triangles do not need to be discarded, because they are never created in the first place.

	~~Its speed and resolution comes from using~~ the ~~Hull + Domain shaders~~ to ~~make only as many copies of each triangle as-needed~~. ~~This means that the vast majority of un-needed triangles do not need~~ to ~~be discarded because they are never created in~~ the ~~first place~~.		Since the Super Pipeline doesn't need to discard triangles, there is no performance hit for having a higher layer limit. The Super Pipeline will, however, limit its maximum layers dynamically, according to the quality settings.

	Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 6600xt, 6700xt, and 6800xt have all been confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be due to a driver bug with nested arrays, which was fixed by modifying the shader code to use a different method. However, the other AMD GPUs appear to be crashing due to memory corruption, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically ~~the~~ GPUs will lockup after about ~10 seconds.		Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 6600xt, 6700xt, and 6800xt have all been confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be due to a driver bug with nested arrays, which was fixed by modifying the shader code to use a different method. However, the other AMD GPUs appear to be crashing due to memory corruption, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically these GPUs will lockup after about ~10 seconds.

	Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.		Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.

	'''The Super Pipeline must NEVER be used in public games!'''		'''The Super Pipeline must NEVER be used in public games!'''

Warren: /* Checked my notes and corrected some factual inaccuracies */

2023-07-05T03:45:45Z

Checked my notes and corrected some factual inaccuracies

Warren: /* Re-worded some things */

2023-07-05T03:33:00Z

Re-worded some things

← Older revision		Revision as of 20:33, 4 July 2023
Line 9:		Line 9:
	The Fallback Pipeline is the slowest pipeline, and will also have the lowest quality. It can render up to 32 layers of fur.		The Fallback Pipeline is the slowest pipeline, and will also have the lowest quality. It can render up to 32 layers of fur.

	~~These limitations are~~ because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory. ~~Even if no fur is being rendered (because it~~ is too far away, or is backwards-facing, or is outside the visible screen area), the Geometry shader ~~must still load everything into GPU memory before discarding any of it~~.		Its lower performance is because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory, and they must reserve enough memory in advance for all possible output triangles, even if they later discard them. Any triangle that is too far away, or is backwards-facing, or is outside the visible screen area will still take time to be discarded by the Geometry shader.

	'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. This is because it doesn't use Hull + Domain shaders, which may not be supported with some games.		'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. This is because it doesn't use Hull + Domain shaders, which may not be supported with some games.
Line 19:		Line 19:
	This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages. This prevents the relatively slow Geometry shaders from loading into GPU memory if they aren't needed.		This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages. This prevents the relatively slow Geometry shaders from loading into GPU memory if they aren't needed.

	Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''The Turbo Pipeline does not use tesselation, though.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer.		Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''The Turbo Pipeline does not use them for tesselation, though.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer, and discarding the rest.

	The Turbo Pipeline is the recommended pipeline.		The Turbo Pipeline is the recommended pipeline.
Line 29:		Line 29:
	Its speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that the vast majority of un-needed triangles do not need to be discarded because they are never created in the first place.		Its speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that the vast majority of un-needed triangles do not need to be discarded because they are never created in the first place.

	Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The 5600xt, 5700xt, and 5800xt are all confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs strike. Typically the ~~GPU~~ will lockup after about ~10 seconds.		Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 5600xt, 5700xt, and 5800xt are all confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be crashing due to a driver bug with nested arrays, which was fixable by modifying the shader code to use a different method. However, the other AMD GPUs appear to be crashing in-between shader stages, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically the GPUs will lockup after about ~10 seconds.

	Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.		Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.

	'''The Super Pipeline must NEVER be used in public games!'''		'''The Super Pipeline must NEVER be used in public games!'''

Warren: /* Initial entry */

2023-07-05T03:19:01Z

Initial entry

Warren: Describes the 3 render pipeline options

2023-07-05T02:52:17Z

Describes the 3 render pipeline options

New page

== [[index.php?title=File:Main_Render_Settings.jpg]]Fast Fur Render Pipeline options ==
WFFS currently uses the Unity Built-in Render Pipeline (BiRP). This graphics pipeline consists of 4 programmable shader stages: Vertex, Hull+Domain, Geometry, and Fragment.

''(NOTE: WFFS does not currently support Unity's other render pipelines, namely the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and Scriptable Render Pipeline (SRP). Future support for these pipelines is planned, but not until the shader is more polished, reliable, and feature-complete.)''

WFFS has 3 options for which BiRP stages to use, and how it will use them:

====== Fallback Pipeline (Slow) ======
[[File:Fallback Pipeline.jpg|none|thumb|The Fallback Pipeline relies on slow Geometry shaders to discard all non-visible fur.]]
The Fallback Pipeline is the slowest pipeline, and will also have the lowest quality. It can render up to 32 layers of fur.

These limitations are because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory. Even if no fur is being rendered (because it is too far away, or is backwards-facing, or is outside the visible screen area), the Geometry shader must still load everything into GPU memory before discarding it.

'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. It doesn't use Hull + Domain shaders, which may not be allowed with some games.

====== Turbo Pipeline (Fast) ======
[[File:Turbo Pipeline.jpg|none|thumb|The Turbo pipeline uses fast Hull + Domain shaders to discard most non-visible fur.]]
Depending on view range, the Turbo Pipeline is typically 25% to 100% faster than the Fallback Pipeline, despite also having much higher quality. It can render up to 32 layers of fur.

This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages, which prevents the relatively slow Geometry shaders from even loading into GPU memory.

Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''The Turbo Pipeline does not use tesselation, though.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer.

The Turbo Pipeline is the recommended pipeline.

'''Super Pipeline (Fastest, but unreliable on AMD GPUs)'''
[[File:Super Pipeline.jpg|none|thumb|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]
The Super Pipeline is typically 30% faster than the Turbo Pipeline, and it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.

Its speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that the vast majority of un-needed triangles do not need to be discarded because they are never created in the first place.

Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a huge performance boost. Unfortunately, it also runs afoul of AMD driver bugs. The 5600xt, 5700xt, and 5800xt are all confirmed to crash during the Hull + Domain shader stages. Unlike the Turbo Pipeline, the Super Pipeline makes copies and modifies the data coming from the Vertex shader before sending it to the Geometry shaders. This is where the AMD driver bugs strike, typically after about ~10 seconds.

Until it can be made reliable on AMD GPUs, the Super Pipeline will not be available except as an experimental Beta version.

'''The Super Pipeline is not recommended.'''

← Older revision		Revision as of 15:53, 9 July 2023
Line 11:		Line 11:
	Its lower performance is because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory, and they must reserve enough memory in advance for all possible output triangles, even if they later discard them. Any triangle that is too far away, or is backwards-facing, or is outside the visible screen area will still take time to be discarded by the Geometry shader.		Its lower performance is because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory, and they must reserve enough memory in advance for all possible output triangles, even if they later discard them. Any triangle that is too far away, or is backwards-facing, or is outside the visible screen area will still take time to be discarded by the Geometry shader.

	Because even discarding triangles still takes some time, selecting a higher maximum layer limit ~~than 16~~ comes with a ~~performace~~ hit, even when less layers are being rendered.		Because even discarding triangles still takes some time, selecting a higher maximum layer limit comes with a performance hit, even when less layers are being rendered.

	'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. This is because it doesn't use Hull + Domain shaders, which may not be supported with some games.		'''''The Fallback Pipeline is not recommended.''''' It is still much faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. This is because it doesn't use Hull + Domain shaders, which may not be supported with some games.

	== Turbo Pipeline (Fast) ==		== Turbo Pipeline (Fast) ==
	[[File:Turbo Pipeline.jpg\|none\|thumb\|The Turbo pipeline uses fast Hull + Domain shaders to discard most non-visible fur.]]		[[File:Turbo Pipeline.jpg\|none\|thumb\|The Turbo pipeline uses fast Hull + Domain shaders to discard most non-visible fur.]]
	Depending on view range, the Turbo Pipeline is typically 25% to 100% faster than the Fallback Pipeline, despite also having much higher quality. It can render up to 32 layers of fur~~. Selecting a higher maximum layer limit comes with a performace hit, even when less layers are being rendered~~.		Depending on view range, the Turbo Pipeline is typically 25% to 100% faster than the Fallback Pipeline, despite also having much higher quality. It can render up to 32 layers of fur.

	This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages. This prevents the relatively slow Geometry shaders from loading into GPU memory if they aren't needed.		This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages. This prevents the relatively slow Geometry shaders from loading into GPU memory if they aren't needed.

	Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''~~The~~ Turbo Pipeline does not use them for tesselation~~, though~~.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer, and discarding the rest.		Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''However, the Turbo Pipeline does '''not''' use them for tesselation.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer, and discarding the rest.

	Because even discarding triangles still takes some time, selecting a higher maximum layer limit ~~than 16~~ comes with a performace hit, even when less layers are being rendered. However, this hit is ~~not as severe as with the Fallback Pipeline~~.		Because even discarding triangles still takes some time, selecting a higher maximum layer limit comes with a performace hit, even when less layers are being rendered. However, this hit is relatively moderate (around 5% going from 24 to 32 layers).

	The Turbo Pipeline is the recommended pipeline.		'''''The Turbo Pipeline is the recommended pipeline.'''''

	== Super Pipeline (Fastest, capable of extremely high resolution, but not usable on some AMD GPUs) ==		== Super Pipeline (Fastest, capable of extremely high resolution, but not usable on some AMD GPUs) ==
	[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]		[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]
	~~'''~~The Super Pipeline is NOT available for public use, due to AMD crashing issues.~~'''~~		The Super Pipeline is NOT available for public use, due to AMD crashing issues. It is not a selectable option in release versions of the shader.

	The Super Pipeline is typically 30% faster than the Turbo Pipeline when rendering at the same quality (ie. up to 32 layers), but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.		The Super Pipeline is typically 30% faster than the Turbo Pipeline when rendering at the same quality (ie. up to 32 layers), but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264(!) layers of fur.

	The Super Pipeline's speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that un-needed triangles do not need to be discarded, because they are never created in the first place.		The Super Pipeline's speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that un-needed triangles do not need to be discarded, because they are never created in the first place.
Line 37:		Line 37:
	Since the Super Pipeline doesn't need to discard triangles, there is no performance hit for having a higher layer limit. The Super Pipeline will, however, limit its maximum layers dynamically, according to the quality settings.		Since the Super Pipeline doesn't need to discard triangles, there is no performance hit for having a higher layer limit. The Super Pipeline will, however, limit its maximum layers dynamically, according to the quality settings.

	Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 6600xt, 6700xt, and 6800xt have all been confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be due to a driver bug with nested arrays, which was fixed by modifying the shader code to ~~use~~ a different method. However, the other AMD GPUs appear to be crashing due to memory corruption, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically these GPUs will lockup after about ~10 seconds.		Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 6600xt, 6700xt, and 6800xt have all been confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be due to a driver bug with nested arrays, which was fixed by modifying the shader code to access the arrays using a different method. However, the other AMD GPUs appear to be crashing due to memory corruption, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically these GPUs will lockup after about ~10 seconds.

	Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.		Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.

	'''The Super Pipeline must NEVER be used in public games!'''		'''''The Super Pipeline must NEVER be used in public games!'''''

← Older revision		Revision as of 20:45, 4 July 2023
Line 3:		Line 3:
	''(NOTE: WFFS does not currently support Unity's other render pipelines, namely the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and Scriptable Render Pipeline (SRP). Future support for these pipelines is planned, but not until the shader is more polished, reliable, and feature-complete.)''		''(NOTE: WFFS does not currently support Unity's other render pipelines, namely the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and Scriptable Render Pipeline (SRP). Future support for these pipelines is planned, but not until the shader is more polished, reliable, and feature-complete.)''

	WFFS has 3 options for ~~which BiRP stages to use, and~~ how it will use ~~them~~:		WFFS has 2 options (not including the experimental Super Pipeline) for how it will use the available BiRP stages:

	== Fallback Pipeline (Slow) ==		== Fallback Pipeline (Slow) ==
Line 23:		Line 23:
	The Turbo Pipeline is the recommended pipeline.		The Turbo Pipeline is the recommended pipeline.

	== Super Pipeline (Fastest, but not ~~reliable~~ on AMD GPUs) ==		== Experimental Beta Version Only: Super Pipeline (Fastest, but not usable on some AMD GPUs) ==
	[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]		[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]
	The Super Pipeline is typically 30% faster than the Turbo Pipeline, but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.		The Super Pipeline is typically 30% faster than the Turbo Pipeline, but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.
Line 29:		Line 29:
	Its speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that the vast majority of un-needed triangles do not need to be discarded because they are never created in the first place.		Its speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that the vast majority of un-needed triangles do not need to be discarded because they are never created in the first place.

	Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, ~~5600xt~~, ~~5700xt~~, and ~~5800xt are~~ all confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be ~~crashing~~ due to a driver bug with nested arrays, which was ~~fixable~~ by modifying the shader code to use a different method. However, the other AMD GPUs appear to be crashing ~~in-between shader stages~~, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically the GPUs will lockup after about ~10 seconds.		Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The Vega 64, 6600xt, 6700xt, and 6800xt have all been confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). The Vega 64 crash was found to be due to a driver bug with nested arrays, which was fixed by modifying the shader code to use a different method. However, the other AMD GPUs appear to be crashing due to memory corruption, which is not fixable by modifying the shader code. Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs seem to strike. Typically the GPUs will lockup after about ~10 seconds.

	Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.		Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.

	'''The Super Pipeline must NEVER be used in public games!'''		'''The Super Pipeline must NEVER be used in public games!'''

← Older revision		Revision as of 20:19, 4 July 2023
Line 1:		Line 1:
	~~== [[index.php?title=File:Main_Render_Settings.jpg]]Fast Fur Render Pipeline options ==~~
	WFFS currently uses the Unity Built-in Render Pipeline (BiRP). This graphics pipeline consists of 4 programmable shader stages: Vertex, Hull+Domain, Geometry, and Fragment.		WFFS currently uses the Unity Built-in Render Pipeline (BiRP). This graphics pipeline consists of 4 programmable shader stages: Vertex, Hull+Domain, Geometry, and Fragment.

Line 6:		Line 5:
	WFFS has 3 options for which BiRP stages to use, and how it will use them:		WFFS has 3 options for which BiRP stages to use, and how it will use them:

	~~====~~== Fallback Pipeline (Slow) ~~====~~==		== Fallback Pipeline (Slow) ==
	[[File:Fallback Pipeline.jpg\|none\|thumb\|The Fallback Pipeline relies on slow Geometry shaders to discard all non-visible fur.]]		[[File:Fallback Pipeline.jpg\|none\|thumb\|The Fallback Pipeline relies on slow Geometry shaders to discard all non-visible fur.]]
	The Fallback Pipeline is the slowest pipeline, and will also have the lowest quality. It can render up to 32 layers of fur.		The Fallback Pipeline is the slowest pipeline, and will also have the lowest quality. It can render up to 32 layers of fur.

	These limitations are because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory. Even if no fur is being rendered (because it is too far away, or is backwards-facing, or is outside the visible screen area), the Geometry shader must still load everything into GPU memory before discarding it.		These limitations are because it relies on Geometry shaders to discard all non-visible triangles. Geometry shaders are unfortunately relatively slow to load into GPU memory. Even if no fur is being rendered (because it is too far away, or is backwards-facing, or is outside the visible screen area), the Geometry shader must still load everything into GPU memory before discarding any of it.

	'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. It doesn't use Hull + Domain shaders, which may not be ~~allowed~~ with some games.		'''''The Fallback Pipeline is not recommended.''''' It is still faster than other fur shaders that use the same approach, such as XSFur, but the only reason it is included is for compatibility reasons. This is because it doesn't use Hull + Domain shaders, which may not be supported with some games.

	~~====~~== Turbo Pipeline (Fast) ~~====~~==		== Turbo Pipeline (Fast) ==
	[[File:Turbo Pipeline.jpg\|none\|thumb\|The Turbo pipeline uses fast Hull + Domain shaders to discard most non-visible fur.]]		[[File:Turbo Pipeline.jpg\|none\|thumb\|The Turbo pipeline uses fast Hull + Domain shaders to discard most non-visible fur.]]
	Depending on view range, the Turbo Pipeline is typically 25% to 100% faster than the Fallback Pipeline, despite also having much higher quality. It can render up to 32 layers of fur.		Depending on view range, the Turbo Pipeline is typically 25% to 100% faster than the Fallback Pipeline, despite also having much higher quality. It can render up to 32 layers of fur.

	This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages~~, which~~ prevents the relatively slow Geometry shaders from ~~even~~ loading into GPU memory.		This speed comes from its use of Hull + Domain shaders to discard any fully non-visible triangles before the Geometry shader stages. This prevents the relatively slow Geometry shaders from loading into GPU memory if they aren't needed.

	Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''The Turbo Pipeline does not use tesselation, though.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer.		Hull + Domain shaders are typically used for tesselation, and are thus built for speed. ''The Turbo Pipeline does not use tesselation, though.'' Instead, it uses the Hull + Domain shaders as a very fast all-or-nothing kill-switch. When it wants to discard an entire triangle, the Hull shader specifies a multiplier of 0, which discards it. Otherwise it specifies a multiplier of 1 and the triangle is then passed completely as-is by the Domain shader to the Geometry shader. The Geometry shader is then resposible for making copies of the triangle for each visible fur layer.
Line 24:		Line 23:
	The Turbo Pipeline is the recommended pipeline.		The Turbo Pipeline is the recommended pipeline.

			== Super Pipeline (Fastest, but not reliable on AMD GPUs) ==
	~~'''~~Super Pipeline (Fastest, but ~~unreliable~~ on AMD GPUs)~~'''~~
	[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]		[[File:Super Pipeline.jpg\|none\|thumb\|The Super Pipeline uses fast Hull + Domain shaders to make the fur layers.]]
	The Super Pipeline is typically 30% faster than the Turbo Pipeline, ~~and~~ it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.		The Super Pipeline is typically 30% faster than the Turbo Pipeline, but it can also produce pixel-perfect screenshots with no visible gaps in the hairs. It can render up to 264 layers of fur.

	Its speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that the vast majority of un-needed triangles do not need to be discarded because they are never created in the first place.		Its speed and resolution comes from using the Hull + Domain shaders to make only as many copies of each triangle as-needed. This means that the vast majority of un-needed triangles do not need to be discarded because they are never created in the first place.

	Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a ~~huge~~ performance boost. Unfortunately, it also runs afoul of AMD driver bugs. The 5600xt, 5700xt, and 5800xt are all confirmed to crash ~~during the Hull + Domain shader stages~~. Unlike the Turbo Pipeline, the Super Pipeline ~~makes copies~~ and ~~modifies~~ the data coming from the Vertex ~~shader~~ before sending it to the Geometry shaders. ~~This~~ is where the AMD driver bugs strike~~, typically~~ after about ~10 seconds.		Offloading most of the copying workload from the much slower Geometry shaders gives the Super Pipeline a big performance boost. Unfortunately, it also runs afoul of AMD driver bugs with some of their GPUs. The 5600xt, 5700xt, and 5800xt are all confirmed to crash (no Intel or Nvidia GPUs have been reported to crash). Unlike the Turbo Pipeline, the Super Pipeline's Domain shaders copy and modify the data coming from the Vertex shaders before sending it to the Geometry shaders. The task of reserving and managing memory for these copies is handled by the GPU drivers, and this is where the AMD driver bugs strike. Typically the GPU will lockup after about ~10 seconds.

	Until it can be ~~made~~ reliable on ~~AMD~~ GPUs, the Super Pipeline will not be available ~~except~~ as an experimental Beta version.		Until driver support can be confirmed to be reliable on '''all''' GPUs, the Super Pipeline will not be available publicly. It currently only exists as an experimental Beta version.

	'''The Super Pipeline ~~is not recommended.~~'''		'''The Super Pipeline must NEVER be used in public games!'''