How to do "Single Pass Instanced" stereo rendering with custom geometry shader

briank · Jul 30, 2018

I have a geometry shader that generates new triangles from an input triangle. I'm trying to make this work on HoloLens using the "Single Pass Instanced" stereo rendering method.

The issue I'm having is that the right eye is not rendering correctly. The position of what is being rendered is noticeably wrong (if you look through the left eye, things line up. If you look through the right eye, the mesh looks correct, but in the wrong location).

I'm not sure if I'm missing something; Most examples I've seen don't use a geometry shader. Any ideas are appreciated.

Roughly, shader code looks like this:

struct appdata
{

float4 vertex : POSITION;
UNITY_VERTEX_INPUT_INSTANCE_ID
};

struct v2g
{

float4 vertex : SV_POSITION;
UNITY_VERTEX_OUTPUT_STEREO
};

struct g2f
{

float4 vertex : SV_POSITION;
UNITY_VERTEX_OUTPUT_STEREO
};

v2g vert(appdata v)
{

v2g o;
UNITY_SETUP_INSTANCE_ID(v);
UNITY_INITIALIZE_OUTPUT(v2g, o);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
o.vertex = UnityObjectToClipPos(v.vertex);
}

[maxvertexcount(4)]
void geom(triangle v2g input[3], inout TriangleStream<g2f> OutputStream)
{

// Geometry shader code generates a quad like shape from the input triangle.

g2f v0 = (g2f)0;
UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input[0], v0);
v0.vertex = UnityWorldToClipPos(pos0);

g2f v1 = (g2f)0;
UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input[0], v1);
v1.vertex = UnityWorldToClipPos(pos1);

g2f v2 = (g2f)0;
UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input[0], v2);
v2.vertex = UnityWorldToClipPos(pos2);

g2f v3 = (g2f)0;
UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input[0], v3);
v3.vertex = UnityWorldToClipPos(pos3);

OutputStream.Append(v0);
OutputStream.Append(v1);
OutputStream.Append(v2);
OutputStream.Append(v3);
OutputStream.RestartStrip();
}

mptp · Aug 2, 2018

I'm fairly sure it's because UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO is supposed to be called in the final shader phase before fragment (i.e. in the geo phase).

I had the same problem as you and am working on it right now - I moved it to the geometry shader phase (one call per output vertex), but now I'm just not getting anything rendering.

I'm sure together we can work this out! I'll post again if I can get it working

mptp · Aug 2, 2018

Aha I've got it!

1. define UNITY_VERTEX_INPUT_INSTANCE_ID in the input of both your vertex shader *and* your geometry shader
2. define UNITY_VERTEX_OUTPUT_STEREO in the input of your fragment shader
3. call UNITY_SETUP_INSTANCE_ID and UNITY_TRANSFER_INSTANCE_ID at the *beginning* of your vertex shader
4. call UNITY_SETUP_INSTANCE_ID at the *beginning* of your geometry shader (this is the one that fixed the wrong positioning for me)
5. call UNITY_INITIALIZE_OUTPUT_STEREO for each vertex you're emitting *before* you append it to whatever output stream you're using

briank · Aug 2, 2018

Thanks for taking a look! I trolled through Unity's cginc's and finally figured out what I need to do. The key part is getting the stereo eye index setup correctly at the beginning of the geom shader.

I ended up doing #1, #2 and #3.

For #4, instead of calling UNITY_SETUP_INSTANCE_ID at the beginning of the geometry shader, I used DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input[0]).

For #5, I continued using UNITY_TRANSFER_VERTEX_OUTPUT_STEREO for each emitted vertex.

pan-master · Oct 21, 2018

Could sombody fix that shader for VR?

Code (CSharp):

Shader "Flex/FlexDrawFluid2" {

Properties {

_Color ("Color", Color) = (1,1,1,1)

//_MainTex ("Albedo (RGB)", 2D) = "white" {}

_Glossiness ("Smoothness", Range(0,1)) = 1.0

_Specular ("Specular", Color) = (0,0,0,1)

_Fresnel ("Fresnel", Range(0,1)) = 1.0

}

SubShader {

Tags { "Queue" = "Geometry" }//Transparent//Geometry

LOD 200

// ------------------------------------------------------------

// Surface shader code generated out of a CGPROGRAM block:

// ---- forward rendering base pass:

Pass {

Name "FORWARD"

Tags { "LightMode" = "ForwardBase" }

Cull off

CGPROGRAM

// compile directives

#pragma vertex vert_flex

#pragma geometry geom_flex

#pragma fragment frag_flex

#pragma target 5.0

#pragma multi_compile_fog

#pragma multi_compile_fwdbase

#include "HLSLSupport.cginc"

#include "UnityShaderVariables.cginc"

// Surface shader code generated based on:

// writes to per-pixel normal: no

// writes to emission: no

// writes to occlusion: no

// needs world space reflection vector: no

// needs world space normal vector: no

// needs screen space position: no

// needs world space position: no

// needs view direction: no

// needs world space view direction: no

// needs world space position for lighting: YES

// needs world space view direction for lighting: YES

// needs world space view direction for lightmaps: no

// needs vertex color: no

// needs VFACE: no

// passes tangent-to-world matrix to pixel shader: no

// reads from normal: no

// 1 texcoords actually used

// float2 _MainTex

#define UNITY_PASS_FORWARDBASE

#include "UnityCG.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#include "AutoLight.cginc"

#define INTERNAL_DATA

#define WorldReflectionVector(data,normal) data.worldRefl

#define WorldNormalVector(data,normal) normal

// Original surface shader snippet:

#line 10 ""

#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING

#endif

/* UNITY: Original start of shader */

// Physically based Standard lighting model, and enable shadows on all light types

//#pragma surface surf StandardSpecular fullforwardshadows addshadow

// Use shader model 3.0 target, to get nicer looking lighting

//#pragma target 3.0

sampler2D _MainTex;

struct Input {

float2 uv_MainTex;

};

half _Fresnel;

half _Glossiness;

fixed4 _Color;

fixed4 _Specular;

void surf (Input IN, inout SurfaceOutputStandardSpecular o) {

// Albedo comes from a texture tinted by color

fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;

float3 vdir = normalize(mul(unity_CameraInvProjection, float4(IN.uv_MainTex * 2.0 - 1.0, 1, 1)));

float fren = saturate(1 - dot(vdir, mul(unity_WorldToCamera, o.Normal)));

//fren = 0.2 + 0.8 * (fren * fren * fren);//;_Fresnel

fren = _Fresnel + (1 - _Fresnel) * (fren * fren * fren);//;_Fresnel

fren = 0.0 + 0.6 * fren;

o.Albedo = 0;//c.rgb * (fren);

o.Emission = c.rgb * (1 - fren);

o.Specular = _Specular * (fren);

o.Smoothness = _Glossiness;

o.Alpha = 0;//c.a;

}

// vertex-to-fragment interpolation data

// no lightmaps:

#ifndef LIGHTMAP_ON

struct v2f_surf {

float4 pos : SV_POSITION;

float2 pack0 : TEXCOORD0; // _MainTex

half3 worldNormal : TEXCOORD1;

float3 worldPos : TEXCOORD2;

#if UNITY_SHOULD_SAMPLE_SH

half3 sh : TEXCOORD3; // SH

#endif

SHADOW_COORDS(4)

UNITY_FOG_COORDS(5)

#if SHADER_TARGET >= 30

float4 lmap : TEXCOORD6;

#endif

UNITY_VERTEX_INPUT_INSTANCE_ID

UNITY_VERTEX_OUTPUT_STEREO

};

#endif

// with lightmaps:

#ifdef LIGHTMAP_ON

struct v2f_surf {

float4 pos : SV_POSITION;

float2 pack0 : TEXCOORD0; // _MainTex

half3 worldNormal : TEXCOORD1;

float3 worldPos : TEXCOORD2;

float4 lmap : TEXCOORD3;

SHADOW_COORDS(4)

UNITY_FOG_COORDS(5)

#ifdef DIRLIGHTMAP_COMBINED

fixed3 tSpace0 : TEXCOORD6;

fixed3 tSpace1 : TEXCOORD7;

fixed3 tSpace2 : TEXCOORD8;

#endif

UNITY_VERTEX_INPUT_INSTANCE_ID

UNITY_VERTEX_OUTPUT_STEREO

};

#endif

float4 _MainTex_ST;

// vertex shader

v2f_surf vert_surf (appdata_full v) {

UNITY_SETUP_INSTANCE_ID(v);

v2f_surf o;

UNITY_INITIALIZE_OUTPUT(v2f_surf,o);

UNITY_TRANSFER_INSTANCE_ID(v,o);

UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

o.pos = UnityObjectToClipPos(v.vertex);

o.pack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);

float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;

fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);

#if defined(LIGHTMAP_ON) && defined(DIRLIGHTMAP_COMBINED)

fixed3 worldTangent = UnityObjectToWorldDir(v.tangent.xyz);

fixed tangentSign = v.tangent.w * unity_WorldTransformParams.w;

fixed3 worldBinormal = cross(worldNormal, worldTangent) * tangentSign;

#endif

#if defined(LIGHTMAP_ON) && defined(DIRLIGHTMAP_COMBINED)

o.tSpace0 = float4(worldTangent.x, worldBinormal.x, worldNormal.x, worldPos.x);

o.tSpace1 = float4(worldTangent.y, worldBinormal.y, worldNormal.y, worldPos.y);

o.tSpace2 = float4(worldTangent.z, worldBinormal.z, worldNormal.z, worldPos.z);

#endif

o.worldPos = worldPos;

o.worldNormal = worldNormal;

#ifdef DYNAMICLIGHTMAP_ON

o.lmap.zw = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;

#endif

#ifdef LIGHTMAP_ON

o.lmap.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;

#endif

// SH/ambient and vertex lights

#ifndef LIGHTMAP_ON

#if UNITY_SHOULD_SAMPLE_SH

o.sh = 0;

// Approximated illumination from non-important point lights

#ifdef VERTEXLIGHT_ON

o.sh += Shade4PointLights (

unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,

unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb,

unity_4LightAtten0, worldPos, worldNormal);

#endif

o.sh = ShadeSHPerVertex (worldNormal, o.sh);

#endif

#endif // !LIGHTMAP_ON

TRANSFER_SHADOW(o); // pass shadow coordinates to pixel shader

UNITY_TRANSFER_FOG(o,o.pos); // pass fog coordinates to pixel shader

return o;

}

// fragment shader

fixed4 frag_surf (v2f_surf IN) : SV_Target {

UNITY_SETUP_INSTANCE_ID(IN);

// prepare and unpack data

Input surfIN;

UNITY_INITIALIZE_OUTPUT(Input,surfIN);

surfIN.uv_MainTex.x = 1.0;

surfIN.uv_MainTex = IN.pack0.xy;

float3 worldPos = IN.worldPos;

#ifndef USING_DIRECTIONAL_LIGHT

fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));

#else

fixed3 lightDir = _WorldSpaceLightPos0.xyz;

#endif

fixed3 worldViewDir = normalize(UnityWorldSpaceViewDir(worldPos));

#ifdef UNITY_COMPILER_HLSL

SurfaceOutputStandardSpecular o = (SurfaceOutputStandardSpecular)0;

#else

SurfaceOutputStandardSpecular o;

#endif

o.Albedo = 0.0;

o.Emission = 0.0;

o.Specular = 0.0;

o.Alpha = 0.0;

o.Occlusion = 1.0;

fixed3 normalWorldVertex = fixed3(0,0,1);

o.Normal = IN.worldNormal;

normalWorldVertex = IN.worldNormal;

// call surface function

surf (surfIN, o);

// compute lighting & shadowing factor

UNITY_LIGHT_ATTENUATION(atten, IN, worldPos)

fixed4 c = 0;

// Setup lighting environment

UnityGI gi;

UNITY_INITIALIZE_OUTPUT(UnityGI, gi);

gi.indirect.diffuse = 0;

gi.indirect.specular = 0;

#if !defined(LIGHTMAP_ON)

gi.light.color = _LightColor0.rgb;

gi.light.dir = lightDir;

#endif

// Call GI (lightmaps/SH/reflections) lighting function

UnityGIInput giInput;

UNITY_INITIALIZE_OUTPUT(UnityGIInput, giInput);

giInput.light = gi.light;

giInput.worldPos = worldPos;

giInput.worldViewDir = worldViewDir;

giInput.atten = atten;

#if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)

giInput.lightmapUV = IN.lmap;

#else

giInput.lightmapUV = 0.0;

#endif

#if UNITY_SHOULD_SAMPLE_SH

giInput.ambient = IN.sh;

#else

giInput.ambient.rgb = 0.0;

#endif

giInput.probeHDR[0] = unity_SpecCube0_HDR;

giInput.probeHDR[1] = unity_SpecCube1_HDR;

#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION

giInput.boxMin[0] = unity_SpecCube0_BoxMin; // .w holds lerp value for blending

#endif

#if UNITY_SPECCUBE_BOX_PROJECTION

giInput.boxMax[0] = unity_SpecCube0_BoxMax;

giInput.probePosition[0] = unity_SpecCube0_ProbePosition;

giInput.boxMax[1] = unity_SpecCube1_BoxMax;

giInput.boxMin[1] = unity_SpecCube1_BoxMin;

giInput.probePosition[1] = unity_SpecCube1_ProbePosition;

#endif

LightingStandardSpecular_GI(o, giInput, gi);

// realtime lighting: call lighting function

c += LightingStandardSpecular (o, worldViewDir, gi);

c.rgb += o.Emission;

UNITY_APPLY_FOG(IN.fogCoord, c); // apply fog

UNITY_OPAQUE_ALPHA(c.a);

return c;

}

#include "FlexDrawFluid.cginc"

ENDCG

}

// ---- forward rendering additive lights pass:

Pass {

Name "FORWARD"

Tags { "LightMode" = "ForwardAdd" }

ZWrite Off Blend One One

CGPROGRAM

// compile directives

#pragma vertex vert_flex

#pragma geometry geom_flex

#pragma fragment frag_flex

#pragma target 5.0

#pragma multi_compile_fog

#pragma multi_compile_fwdadd_fullshadows

#pragma skip_variants INSTANCING_ON

#include "HLSLSupport.cginc"

#include "UnityShaderVariables.cginc"

// Surface shader code generated based on:

// writes to per-pixel normal: no

// writes to emission: no

// writes to occlusion: no

// needs world space reflection vector: no

// needs world space normal vector: no

// needs screen space position: no

// needs world space position: no

// needs view direction: no

// needs world space view direction: no

// needs world space position for lighting: YES

// needs world space view direction for lighting: YES

// needs world space view direction for lightmaps: no

// needs vertex color: no

// needs VFACE: no

// passes tangent-to-world matrix to pixel shader: no

// reads from normal: no

// 1 texcoords actually used

// float2 _MainTex

#define UNITY_PASS_FORWARDADD

#include "UnityCG.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#include "AutoLight.cginc"

#define INTERNAL_DATA

#define WorldReflectionVector(data,normal) data.worldRefl

#define WorldNormalVector(data,normal) normal

// Original surface shader snippet:

#line 10 ""

#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING

#endif

/* UNITY: Original start of shader */

// Physically based Standard lighting model, and enable shadows on all light types

//#pragma surface surf StandardSpecular fullforwardshadows addshadow

// Use shader model 3.0 target, to get nicer looking lighting

//#pragma target 3.0

sampler2D _MainTex;

struct Input {

float2 uv_MainTex;

};

half _Glossiness;

fixed4 _Color;

fixed4 _Specular;

void surf (Input IN, inout SurfaceOutputStandardSpecular o) {

// Albedo comes from a texture tinted by color

fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;

o.Albedo = c.rgb;

// Specular and smoothness come from slider variables

o.Specular = _Specular;

o.Smoothness = _Glossiness;

o.Alpha = c.a;

}

// vertex-to-fragment interpolation data

struct v2f_surf {

float4 pos : SV_POSITION;

float2 pack0 : TEXCOORD0; // _MainTex

half3 worldNormal : TEXCOORD1;

float3 worldPos : TEXCOORD2;

SHADOW_COORDS(3)

UNITY_FOG_COORDS(4)

};

float4 _MainTex_ST;

// vertex shader

v2f_surf vert_surf (appdata_full v) {

v2f_surf o;

UNITY_INITIALIZE_OUTPUT(v2f_surf,o);

o.pos = UnityObjectToClipPos(v.vertex);

o.pack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);

float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;

fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);

o.worldPos = worldPos;

o.worldNormal = worldNormal;

TRANSFER_SHADOW(o); // pass shadow coordinates to pixel shader

UNITY_TRANSFER_FOG(o,o.pos); // pass fog coordinates to pixel shader

return o;

}

// fragment shader

fixed4 frag_surf (v2f_surf IN) : SV_Target {

// prepare and unpack data

Input surfIN;

UNITY_INITIALIZE_OUTPUT(Input,surfIN);

surfIN.uv_MainTex.x = 1.0;

surfIN.uv_MainTex = IN.pack0.xy;

float3 worldPos = IN.worldPos;

#ifndef USING_DIRECTIONAL_LIGHT

fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));

#else

fixed3 lightDir = _WorldSpaceLightPos0.xyz;

#endif

fixed3 worldViewDir = normalize(UnityWorldSpaceViewDir(worldPos));

#ifdef UNITY_COMPILER_HLSL

SurfaceOutputStandardSpecular o = (SurfaceOutputStandardSpecular)0;

#else

SurfaceOutputStandardSpecular o;

#endif

o.Albedo = 0.0;

o.Emission = 0.0;

o.Specular = 0.0;

o.Alpha = 0.0;

o.Occlusion = 1.0;

fixed3 normalWorldVertex = fixed3(0,0,1);

o.Normal = IN.worldNormal;

normalWorldVertex = IN.worldNormal;

// call surface function

surf (surfIN, o);

UNITY_LIGHT_ATTENUATION(atten, IN, worldPos)

fixed4 c = 0;

// Setup lighting environment

UnityGI gi;

UNITY_INITIALIZE_OUTPUT(UnityGI, gi);

gi.indirect.diffuse = 0;

gi.indirect.specular = 0;

#if !defined(LIGHTMAP_ON)

gi.light.color = _LightColor0.rgb;

gi.light.dir = lightDir;

#endif

gi.light.color *= atten;

c += LightingStandardSpecular (o, worldViewDir, gi);

c.a = 0.0;

UNITY_APPLY_FOG(IN.fogCoord, c); // apply fog

UNITY_OPAQUE_ALPHA(c.a);

return c;

}

#include "FlexDrawFluid.cginc"

ENDCG

}

// ---- deferred shading pass:

Pass {

Name "DEFERRED"

Tags { "LightMode" = "Deferred" }

CGPROGRAM

// compile directives

#pragma vertex vert_flex

#pragma geometry geom_flex

#pragma fragment frag_flex

#pragma target 5.0

#pragma exclude_renderers nomrt

#pragma multi_compile_prepassfinal

#pragma skip_variants FOG_LINEAR FOG_EXP FOG_EXP2

#include "HLSLSupport.cginc"

#include "UnityShaderVariables.cginc"

// Surface shader code generated based on:

// writes to per-pixel normal: no

// writes to emission: no

// writes to occlusion: no

// needs world space reflection vector: no

// needs world space normal vector: no

// needs screen space position: no

// needs world space position: no

// needs view direction: no

// needs world space view direction: no

// needs world space position for lighting: YES

// needs world space view direction for lighting: YES

// needs world space view direction for lightmaps: no

// needs vertex color: no

// needs VFACE: no

// passes tangent-to-world matrix to pixel shader: no

// reads from normal: YES

// 1 texcoords actually used

// float2 _MainTex

#define UNITY_PASS_DEFERRED

#include "UnityCG.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#define INTERNAL_DATA

#define WorldReflectionVector(data,normal) data.worldRefl

#define WorldNormalVector(data,normal) normal

// Original surface shader snippet:

#line 10 ""

#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING

#endif

/* UNITY: Original start of shader */

// Physically based Standard lighting model, and enable shadows on all light types

//#pragma surface surf StandardSpecular fullforwardshadows addshadow

// Use shader model 3.0 target, to get nicer looking lighting

//#pragma target 3.0

sampler2D _MainTex;

struct Input {

float2 uv_MainTex;

};

half _Glossiness;

fixed4 _Color;

fixed4 _Specular;

void surf (Input IN, inout SurfaceOutputStandardSpecular o) {

// Albedo comes from a texture tinted by color

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);// * _Color;

o.Albedo = c.rgb; //o.Emission = 1;//c.rgb;

// Specular and smoothness come from slider variables

o.Specular = _Specular;

o.Smoothness = _Glossiness;

o.Alpha = c.a;

}

// vertex-to-fragment interpolation data

struct v2f_surf {

float4 pos : SV_POSITION;

float2 pack0 : TEXCOORD0; // _MainTex

half3 worldNormal : TEXCOORD1;

float3 worldPos : TEXCOORD2;

#ifndef DIRLIGHTMAP_OFF

half3 viewDir : TEXCOORD3;

#endif

float4 lmap : TEXCOORD4;

#ifndef LIGHTMAP_ON

#if UNITY_SHOULD_SAMPLE_SH

half3 sh : TEXCOORD5; // SH

#endif

#else

#ifdef DIRLIGHTMAP_OFF

float4 lmapFadePos : TEXCOORD5;

#endif

#endif

UNITY_VERTEX_INPUT_INSTANCE_ID

UNITY_VERTEX_OUTPUT_STEREO

};

float4 _MainTex_ST;

// vertex shader

v2f_surf vert_surf (appdata_full v) {

UNITY_SETUP_INSTANCE_ID(v);

v2f_surf o;

UNITY_INITIALIZE_OUTPUT(v2f_surf,o);

UNITY_TRANSFER_INSTANCE_ID(v,o);

UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

o.pos = UnityObjectToClipPos(v.vertex);

o.pack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);

float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;

fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);

o.worldPos = worldPos;

o.worldNormal = worldNormal;

float3 viewDirForLight = UnityWorldSpaceViewDir(worldPos);

#ifndef DIRLIGHTMAP_OFF

o.viewDir = viewDirForLight;

#endif

#ifdef DYNAMICLIGHTMAP_ON

o.lmap.zw = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;

#else

o.lmap.zw = 0;

#endif

#ifdef LIGHTMAP_ON

o.lmap.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;

#ifdef DIRLIGHTMAP_OFF

o.lmapFadePos.xyz = (mul(unity_ObjectToWorld, v.vertex).xyz - unity_ShadowFadeCenterAndType.xyz) * unity_ShadowFadeCenterAndType.w;

o.lmapFadePos.w = (-UnityObjectToViewPos(v.vertex).z) * (1.0 - unity_ShadowFadeCenterAndType.w);

#endif

#else

o.lmap.xy = 0;

#if UNITY_SHOULD_SAMPLE_SH

o.sh = 0;

o.sh = ShadeSHPerVertex (worldNormal, o.sh);

#endif

#endif

return o;

}

#ifdef LIGHTMAP_ON

float4 unity_LightmapFade;

#endif

fixed4 unity_Ambient;

// fragment shader

void frag_surf(v2f_surf IN,

out half4 outGBuffer0 : SV_Target0,

out half4 outGBuffer1 : SV_Target1,

out half4 outGBuffer2 : SV_Target2,

out half4 outEmission : SV_Target3)

{

UNITY_SETUP_INSTANCE_ID(IN);

// prepare and unpack data

Input surfIN;

UNITY_INITIALIZE_OUTPUT(Input, surfIN);

surfIN.uv_MainTex.x = 1.0;

surfIN.uv_MainTex = IN.pack0.xy;

float3 worldPos = IN.worldPos;

#ifndef USING_DIRECTIONAL_LIGHT

fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));

#else

fixed3 lightDir = _WorldSpaceLightPos0.xyz;

#endif

fixed3 worldViewDir = normalize(UnityWorldSpaceViewDir(worldPos));

#ifdef UNITY_COMPILER_HLSL

SurfaceOutputStandardSpecular o = (SurfaceOutputStandardSpecular)0;

#else

SurfaceOutputStandardSpecular o;

#endif

o.Albedo = 0.0;

o.Emission = 0.0;

o.Specular = 0.0;

o.Alpha = 0.0;

o.Occlusion = 1.0;

fixed3 normalWorldVertex = fixed3(0, 0, 1);

o.Normal = IN.worldNormal;

normalWorldVertex = IN.worldNormal;

// call surface function

surf(surfIN, o);

fixed3 originalNormal = o.Normal;

half atten = 1;

// Setup lighting environment

UnityGI gi;

UNITY_INITIALIZE_OUTPUT(UnityGI, gi);

gi.indirect.diffuse = 0;

gi.indirect.specular = 0;

gi.light.color = 0;

gi.light.dir = half3(0, 1, 0);

// Call GI (lightmaps/SH/reflections) lighting function

UnityGIInput giInput;

UNITY_INITIALIZE_OUTPUT(UnityGIInput, giInput);

giInput.light = gi.light;

giInput.worldPos = worldPos;

giInput.worldViewDir = worldViewDir;

giInput.atten = atten;

#if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)

giInput.lightmapUV = IN.lmap;

#else

giInput.lightmapUV = 0.0;

#endif

#if UNITY_SHOULD_SAMPLE_SH

giInput.ambient = IN.sh;

#else

giInput.ambient.rgb = 0.0;

#endif

giInput.probeHDR[0] = unity_SpecCube0_HDR;

giInput.probeHDR[1] = unity_SpecCube1_HDR;

#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION

giInput.boxMin[0] = unity_SpecCube0_BoxMin; // .w holds lerp value for blending

#endif

#if UNITY_SPECCUBE_BOX_PROJECTION

giInput.boxMax[0] = unity_SpecCube0_BoxMax;

giInput.probePosition[0] = unity_SpecCube0_ProbePosition;

giInput.boxMax[1] = unity_SpecCube1_BoxMax;

giInput.boxMin[1] = unity_SpecCube1_BoxMin;

giInput.probePosition[1] = unity_SpecCube1_ProbePosition;

#endif

LightingStandardSpecular_GI(o, giInput, gi);

// call lighting function to output g-buffer

outEmission = LightingStandardSpecular_Deferred(o, worldViewDir, gi, outGBuffer0, outGBuffer1, outGBuffer2);

#ifndef UNITY_HDR_ON

outEmission.rgb = exp2(-outEmission.rgb);

#endif

}

#include "FlexDrawFluid.cginc"

ENDCG

}

// ---- shadow caster pass:

Pass {

Name "ShadowCaster"

Tags { "LightMode" = "ShadowCaster" }

ZWrite On ZTest LEqual

Cull Off

CGPROGRAM

// compile directives

#pragma vertex vert_flex

#pragma geometry geom_flex

#pragma fragment frag_flex

#pragma target 5.0

#pragma multi_compile_shadowcaster

#pragma skip_variants FOG_LINEAR FOG_EXP FOG_EXP2

#include "HLSLSupport.cginc"

#include "UnityShaderVariables.cginc"

// Surface shader code generated based on:

// writes to per-pixel normal: no

// writes to emission: no

// writes to occlusion: no

// needs world space reflection vector: no

// needs world space normal vector: no

// needs screen space position: no

// needs world space position: no

// needs view direction: no

// needs world space view direction: no

// needs world space position for lighting: YES

// needs world space view direction for lighting: YES

// needs world space view direction for lightmaps: no

// needs vertex color: no

// needs VFACE: no

// passes tangent-to-world matrix to pixel shader: no

// reads from normal: no

// 0 texcoords actually used

#define UNITY_PASS_SHADOWCASTER

#include "UnityCG.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#define INTERNAL_DATA

#define WorldReflectionVector(data,normal) data.worldRefl

#define WorldNormalVector(data,normal) normal

// Original surface shader snippet:

#line 10 ""

#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING

#endif

/* UNITY: Original start of shader */

// Physically based Standard lighting model, and enable shadows on all light types

//#pragma surface surf StandardSpecular fullforwardshadows addshadow

// Use shader model 3.0 target, to get nicer looking lighting

//#pragma target 3.0

sampler2D _MainTex;

struct Input {

float2 uv_MainTex;

};

half _Glossiness;

fixed4 _Color;

fixed4 _Specular;

void surf (Input IN, inout SurfaceOutputStandardSpecular o) {

// Albedo comes from a texture tinted by color

fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;

o.Albedo = c.rgb;

// Specular and smoothness come from slider variables

o.Specular = _Specular;

o.Smoothness = _Glossiness;

o.Alpha = 1;//c.a;

}

// vertex-to-fragment interpolation data

struct v2f_surf {

V2F_SHADOW_CASTER;

float3 worldPos : TEXCOORD1;

UNITY_VERTEX_INPUT_INSTANCE_ID

UNITY_VERTEX_OUTPUT_STEREO

};

// vertex shader

v2f_surf vert_surf (appdata_full v) {

UNITY_SETUP_INSTANCE_ID(v);

v2f_surf o;

UNITY_INITIALIZE_OUTPUT(v2f_surf,o);

UNITY_TRANSFER_INSTANCE_ID(v,o);

UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);

float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;

fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);

o.worldPos = worldPos;

TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)

return o;

}

// fragment shader

fixed4 frag_surf (v2f_surf IN) : SV_Target {

UNITY_SETUP_INSTANCE_ID(IN);

// prepare and unpack data

Input surfIN;

UNITY_INITIALIZE_OUTPUT(Input,surfIN);

surfIN.uv_MainTex.x = 1.0;

float3 worldPos = IN.worldPos;

#ifndef USING_DIRECTIONAL_LIGHT

fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));

#else

fixed3 lightDir = _WorldSpaceLightPos0.xyz;

#endif

#ifdef UNITY_COMPILER_HLSL

SurfaceOutputStandardSpecular o = (SurfaceOutputStandardSpecular)0;

#else

SurfaceOutputStandardSpecular o;

#endif

o.Albedo = 0.0;

o.Emission = 0.0;

o.Specular = 0.0;

o.Alpha = 0.0;

o.Occlusion = 1.0;

fixed3 normalWorldVertex = fixed3(0,0,1);

// call surface function

surf (surfIN, o);

SHADOW_CASTER_FRAGMENT(IN)

}

#include "FlexDrawFluid.cginc"

ENDCG

}

// ---- meta information extraction pass:

Pass {

Name "Meta"

Tags { "LightMode" = "Meta" }

Cull Off

CGPROGRAM

// compile directives

#pragma vertex vert_surf

#pragma fragment frag_surf

#pragma target 3.0

#pragma skip_variants FOG_LINEAR FOG_EXP FOG_EXP2

#pragma skip_variants INSTANCING_ON

#include "HLSLSupport.cginc"

#include "UnityShaderVariables.cginc"

// Surface shader code generated based on:

// writes to per-pixel normal: no

// writes to emission: no

// writes to occlusion: no

// needs world space reflection vector: no

// needs world space normal vector: no

// needs screen space position: no

// needs world space position: no

// needs view direction: no

// needs world space view direction: no

// needs world space position for lighting: YES

// needs world space view direction for lighting: YES

// needs world space view direction for lightmaps: no

// needs vertex color: no

// needs VFACE: no

// passes tangent-to-world matrix to pixel shader: no

// reads from normal: no

// 1 texcoords actually used

// float2 _MainTex

#define UNITY_PASS_META

#include "UnityCG.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#define INTERNAL_DATA

#define WorldReflectionVector(data,normal) data.worldRefl

#define WorldNormalVector(data,normal) normal

// Original surface shader snippet:

#line 10 ""

#ifdef DUMMY_PREPROCESSOR_TO_WORK_AROUND_HLSL_COMPILER_LINE_HANDLING

#endif

/* UNITY: Original start of shader */

// Physically based Standard lighting model, and enable shadows on all light types

//#pragma surface surf StandardSpecular fullforwardshadows addshadow

// Use shader model 3.0 target, to get nicer looking lighting

//#pragma target 3.0

sampler2D _MainTex;

struct Input {

float2 uv_MainTex;

};

half _Glossiness;

fixed4 _Color;

fixed4 _Specular;

void surf (Input IN, inout SurfaceOutputStandardSpecular o) {

// Albedo comes from a texture tinted by color

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);// * _Color;

o.Albedo = c.rgb; o.Emission = c.rgb;

// Specular and smoothness come from slider variables

o.Specular = _Specular;

o.Smoothness = _Glossiness;

o.Alpha = c.a;

}

#include "UnityMetaPass.cginc"

// vertex-to-fragment interpolation data

struct v2f_surf {

float4 pos : SV_POSITION;

float2 pack0 : TEXCOORD0; // _MainTex

float3 worldPos : TEXCOORD1;

};

float4 _MainTex_ST;

// vertex shader

v2f_surf vert_surf (appdata_full v) {

v2f_surf o;

UNITY_INITIALIZE_OUTPUT(v2f_surf,o);

o.pos = UnityMetaVertexPosition(v.vertex, v.texcoord1.xy, v.texcoord2.xy, unity_LightmapST, unity_DynamicLightmapST);

o.pack0.xy = TRANSFORM_TEX(v.texcoord, _MainTex);

float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;

fixed3 worldNormal = UnityObjectToWorldNormal(v.normal);

o.worldPos = worldPos;

return o;

}

// fragment shader

fixed4 frag_surf (v2f_surf IN) : SV_Target {

// prepare and unpack data

Input surfIN;

UNITY_INITIALIZE_OUTPUT(Input,surfIN);

surfIN.uv_MainTex.x = 1.0;

surfIN.uv_MainTex = IN.pack0.xy;

float3 worldPos = IN.worldPos;

#ifndef USING_DIRECTIONAL_LIGHT

fixed3 lightDir = normalize(UnityWorldSpaceLightDir(worldPos));

#else

fixed3 lightDir = _WorldSpaceLightPos0.xyz;

#endif

#ifdef UNITY_COMPILER_HLSL

SurfaceOutputStandardSpecular o = (SurfaceOutputStandardSpecular)0;

#else

SurfaceOutputStandardSpecular o;

#endif

o.Albedo = 0.0;

o.Emission = 0.0;

o.Specular = 0.0;

o.Alpha = 0.0;

o.Occlusion = 1.0;

fixed3 normalWorldVertex = fixed3(0,0,1);

// call surface function

surf (surfIN, o);

UnityMetaInput metaIN;

UNITY_INITIALIZE_OUTPUT(UnityMetaInput, metaIN);

metaIN.Albedo = o.Albedo;

metaIN.Emission = o.Emission;

return UnityMetaFragment(metaIN);

}

ENDCG

}

// ---- end of surface shader generated code

#LINE 38

}

FallBack Off

}

G33RT · Feb 11, 2020

briank said: ↑

Thanks for taking a look! I trolled through Unity's cginc's and finally figured out what I need to do. The key part is getting the stereo eye index setup correctly at the beginning of the geom shader.

I ended up doing #1, #2 and #3.

For #4, instead of calling UNITY_SETUP_INSTANCE_ID at the beginning of the geometry shader, I used DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input[0]).

For #5, I continued using UNITY_TRANSFER_VERTEX_OUTPUT_STEREO for each emitted vertex.
Click to expand...

I'm trying to reconstruct what you did to get it working with my geometry shader, but without succes. Could we have a look at the final (working) result, the shader code?

That would really make my day (or week )

mmvirsabi · Oct 23, 2020

briank said: ↑

Thanks for taking a look! I trolled through Unity's cginc's and finally figured out what I need to do. The key part is getting the stereo eye index setup correctly at the beginning of the geom shader.

I ended up doing #1, #2 and #3.

For #4, instead of calling UNITY_SETUP_INSTANCE_ID at the beginning of the geometry shader, I used DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input[0]).

For #5, I continued using UNITY_TRANSFER_VERTEX_OUTPUT_STEREO for each emitted vertex.
Click to expand...

I have the same issue with a MRTK shader. Can you please post your shader from other people to learn from. Thank you

homoinanis · Dec 11, 2022

I have searched a lot on the internet. I can save you time. One day as of this post Unity offers absolutely nothing to get a single render texture with stereoscopic view using Single Instance.

But of course, there is the issue that if you want to make a relatively complex game Single Instance is practically mandatory.

The only solution I have found is also quite simple: use two cameras for each of the eyes of the HMD viewer. So, for each stereoscopic texture that we want, for example a portal, we will have to create two cameras that will track the position of the eyes in a relative way, recording the texture in two render textures that we can assign to each of the textures of a shader that unify in a single vision.

bgolus · Dec 11, 2022

homoinanis said: ↑

I have searched a lot on the internet.
Click to expand...

... your post is entirely unrelated to the topic of this thread.

Search Unity

Unity ID

Useful Searches

How to do "Single Pass Instanced" stereo rendering with custom geometry shader