3D Depth Map Based Stereoscopic Shader

x8009 wrote: Version 3.0.7 was released on April 1st 2017. !!

no idea how ! xD

reshade.me/

EDIT : Also BlueSkyKnight , there is error with the Experimental SuperDepth3D , it says Error Compiling SamplerCDM or something
EDIT : Also SuperDepth3D_FlashBack has lower performance than the SuperDepth3D , I had some FPS drops in same game BladeStorm Nightmare in the same area with FlashBack but no FPS drop with normal SuperDepth3D so only use FlashBack when there is no choice or something

And thanks for the new Shaders ! Awesome with every release xD

BlueSkyKnight wrote:

x8009 wrote: Version 3.0.7 was released on April 1st 2017. !!

no idea how ! xD

reshade.me/

EDIT : Also BlueSkyKnight , there is error with the Experimental SuperDepth3D , it says Error Compiling SamplerCDM or something
EDIT : Also SuperDepth3D_FlashBack has lower performance than the SuperDepth3D , I had some FPS drops in same game BladeStorm Nightmare in the same area with FlashBack but no FPS drop with normal SuperDepth3D so only use FlashBack when there is no choice or something

And thanks for the new Shaders ! Awesome with every release xD

SuperDepth3D_FlashBack Performance drop is normal it's a older way of doing 3D.

Don't use the one in the experimental folder. That shader need to be worked on. That one Depth3D. So right now it would give a error since I didn't want people to use it yet.

sgsrules wrote: Hi BlueSkyDefender, First off awesome work! I was pretty sure that I wouldn't be seeing BOTW in 3d using Nvidia's 3dVision anytime soon since all the real 3d wrappers like helixmod and 3dmigoto only work with directx and Cemu is OpenGL. But thanks to you and helifax (The creater of a OpenGL 3dvision wrapper) I was able to get BOTW working. There are also texture packs for cemu that let you run the game at higher resolutions like 1080p or even 4k. With the newest version of cemu (1.7.4) The game runs at 20-30fps (25 outdoor) on my rig and doesn't have that many bugs.

sgsrules wrote: Anyhow I installed the OpenGL wrapper + reshade and your shader and it looks pretty good so far using the default DM0 except that nearby objects are fairly flat. Do you know if the game uses a linear depth map or is it logarithmic? I see that you're screenshots said you're using dm 6 and looking at the shader:

float cF = 25;
float cN = 0;
depthM = (pow(abs(cN-depthM),cF));

which simplifies to

depthM = pow(depthM,25);

so you're basically raising the depth map by a power of 25 using a power curve. Is there a reason why you can't just sample the depth linearly? Or does raising it by a power work better?

sgsrules wrote: Also whats the best way to test changes to the shader out?

sgsrules wrote: Unfortunately Cemu takes a while to load so having to quit and restart everytime i make a change is a pain in the ass. I though about using a laptop and networking in to modify the shader, which is what i do when fixing shaders using 3migoto but i don't know how to reload the shader from within the game. To further complicate things reshade's menu won't work since, probably because I'm using a wrapper for OpenGL.

sgsrules wrote: Yes you can get a fullscreen depth image from cemu. I had to change my desktop resolution to match the resolution that was being used in the texure packs before launching cemu, otherwise reshade doesnt work properly. You also need to launch cemu with the -f and -g "game location" for fullscreen and automatically launching a game at startup. You also need to tell cemu to render upside down as well as flipping the depth buffer in your shader settings.

sgsrules wrote: I know that none of your code was specific to Cemu. No i haven't tried all 40 dm settings, and wamted to avoid doing that since it would take forever to randomly test each one out. Using anaglyph glasses without the opengl wrapper seems like a viable solution. But i noticed that you only use a handful of equations with different values for the far and near clipping planes and wanted to figure out what the reasoning for them was. Thanks for linking that article but Im familiar with how a depth buffer is encoded, i mainly wanted to know how the different equations were derived.

Cheers!

sgsrules wrote: Sure I'd love to give a hand.

One more question before i dive into this. The depth map which is generally encoded into a 0-1 range and get's remapped using one of the depth map equations that you're using. What does the final value after the remapping correspond to? Is this the linear depth in eye coordinates (aka view space)? for example in OpenGL you would do something like this:

    float zbufferDepth= texture2D(depthBuffTex, uvCoord).x;
    float zNorm = 2.0 * zbufferDepth- 1.0; //converts from [0]-[1] to [-1]-[1]
    float eyeDepth = 2.0 * zNear * zFar / (zFar + zNear - zNorm * (zFar - zNear));

to obtain the depth in view coordinates from the depth buffer. Or is the DepthM value that you're using in a different coordinate space like clip space?

texture DepthBufferTex : DEPTH;

sampler DepthBuffer 
	{ 
		Texture = DepthBufferTex; 
	};

		//Custom Thirteen
		if (Custom_Depth_Map == 13)
		{
                float zNorm = 2.0 *depthM- 1.0;
		float cF = Near_Far.y;//
		float cN = Near_Far.x;//
		depthM = 2.0 * cN * cF / (cF + cN - zNorm * (cF - cN));
		}

Looks good so far with most games. I think, I will treat Fez as a special case.

Good Job sgsrules.

So I'm assuming for direct X clip space should be adjust as well. [0,1] range as compared with openGL [-1,1]

	if (Depth_Map == 9)
		{
		float cF = 1;
		float cN = 0.005;
		depthM = cN/(cN-cF) / ( depthM – cF/(cF-cN));
		Color = depthM.rrr; //Sets the final color
		return;// exits the shader
		}

float cF = Near_Far.y;//  Near_Far value passed in as a uniform.
float cN = Near_Far.x;//
[call] switch(Depth_Map )
{
	case 0:		//Alien Isolation | Firewatch
		depthM = (exp(depthM * log(cF + cN)) - cN) / cF;
		break;
	case 1: 	//OpenGL Games |Amnesia: The Dark Descent| Soma etc..
		float zNorm = 2.0 *depthM- 1.0;
		depthM = 2.0 * cN * cF / (cF + cN - zNorm * (cF - cN));
		break;
	default:	//Standard DirectX
		depthM = 2.0 * cN * cF / (cF + cN - zNorm * (cF - cN));
		break;
}

sgsrules wrote: What sort of values are you using for the near and far clip planes? The above equation will linearize depth in view space coordinates, I suspect that the stereo offset values that you calculate in your shader are in clip space coordinates. learnopengl.com/#!Getting-started/Coordinate-Systems If so then you would need to transform the calculated depthM value to clips space my applying a projection transformation. But this is only true if the near and far clip plane values are in the games world or view space coordinates e.g. near= 1 far= 1000 (depending on this games units). Since we don't have access to the projection matrix we can probably just use near and far clip plane values in the -1 to 1 range or 0 to 1 range.

sgsrules wrote: I'm assuming the same things as well since OpenGL and DirectX use similar transformations. The other thing that may be different is that you might have to switch signs for the depth because If i'm not mistaken DirectX uses positive values to go “into” the screen as opposed to OpenGL which uses negative values.

Another thing I would suggest is to optimize your code by reducing the number of conditional if statements. Having conditionals in shaders can often have a serious performance impact on the code. Compilers can sometimes find clever ways to optimize them away, but if your shader code really does have to branch and perform comparisons the speed can drop off significantly.

sgsrules wrote: First off, Instead of having 40 different equations you could reduce the duplicate equations by passing in the cN and cF values as user editable uniform variables. This way you would only have a handful of equations and it would also let the user fine tune the variables.

sgsrules wrote: Another suggestion would be to exit out of the if statement early. Right now even if Depth_Map = 0 the shader still has to evaluate the rest of the 40+ if statements. So instead you could do something like:

	if (Depth_Map == 9)
		{
		float cF = 1;
		float cN = 0.005;
		depthM = cN/(cN-cF) / ( depthM – cF/(cF-cN));
		Color = depthM.rrr; //Sets the final color
		return;// exits the shader
		}

This way it only evaluates the first if statement that is true and sets the final color and skips the rest. Another solution would be to chain your if statements with if else() instead, just keep in mind that there a still a performance cost even if it skips over the following if else statements.

Even better yet use a switch statement with a [call] attribute msdn.microsoft.com/en-us/library/windows...509669(v=vs.85).aspx The call attribute turns the switch statement into a subroutine. If you don't use the call attribute each skipped statement costs 1 cycle so doing a switch with 40 statements would cost you 40 cycles. Using the call statement has about a 5 cycle overhead to setup so if you're using less than 4 or 5 statements it's not necessary. In this case since you have 40+ it's definitely worth it. The call attribute also requires DirectX 10 which should be supported by Reshade 3.0 but if you have issues just leave the [call] out, the switch statement will still perform better than the multiple ifs you currently have in place and the syntax is cleaner as well. Here's some sample code:

float cF = Near_Far.y;//  Near_Far value passed in as a uniform.
float cN = Near_Far.x;//
[call] switch(Depth_Map )
{
	case 0:		//Alien Isolation | Firewatch
		depthM = (exp(depthM * log(cF + cN)) - cN) / cF;
		break;
	case 1: 	//OpenGL Games |Amnesia: The Dark Descent| Soma etc..
		float zNorm = 2.0 *depthM- 1.0;
		depthM = 2.0 * cN * cF / (cF + cN - zNorm * (cF - cN));
		break;
	default:	//Standard DirectX
		depthM = 2.0 * cN * cF / (cF + cN - zNorm * (cF - cN));
		break;
}

sgsrules wrote: Anyhow sorry about the wall of texts but I hope it helps.

Also as much as I want to use the flow control switch statements they incompatible with dx9 it seems... But, since I am removing most profiles it will not change much anyways.

switch(Depth_Map )
{
	case 0:		//Alien Isolation | Firewatch
		depthM = (exp(depthM * log(cF + cN)) - cN) / cF;
		break;
	case 1: 	//OpenGL Games |Amnesia: The Dark Descent| Soma etc..
		float zNorm = 2.0 *depthM- 1.0;
		depthM = 2.0 * cN * cF / (cF + cN - zNorm * (cF - cN));
		break;
	default:	//Standard DirectX
		depthM = 2.0 * cN * cF / (cF + cN - zNorm * (cF - cN));
		break;
}