유니티 2019에서는 발생 안 하다가 2022에서 급작스럽게 발생했다.

원인은 struct v2f의 UNITY_VERTEX_OUTPUT_STEREO 구조변경 때문이다.

appdata와 vert에 아래구문을 추가한다

struct appdata
{
    UNITY_VERTEX_INPUT_INSTANCE_ID
};
v2f vert (appdata v)
{
    v2f o;

    UNITY_SETUP_INSTANCE_ID(v);
    UNITY_INITIALIZE_OUTPUT(v2f, o); 
    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
}

참고링크 : https://docs.unity3d.com/kr/2019.4/Manual/SinglePassInstancing.html

위와 같은 문제이다.

위와 다른점은 위에건 버텍스 프래그 쉐이더를 썼지만 이건 서피스와 버텍스 혼합 쉐이더에서 발생한 차이점이 있다.

내 경우엔 프래그를 안 가져와서 void vert이기 때문에 appdata에 아래 구문 추가하는거로 끝났다.

struct appdata
{
    UNITY_VERTEX_INPUT_INSTANCE_ID
};

Shader "Unlit/AndroidDepth"
{
    Properties
    {
		_DepthTex("_DepthTex", 2D) = "white" {}
    }
    SubShader
    {
        Tags { 
		"RenderType" = "Transparent"
		"Queue" = "Transparent"
        }
        LOD 100
        
        ZWrite Off

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;

				float4 screenPos : TEXCOORD1;
            };

            
			sampler2D _DepthTex;
			float4 _DepthTex_ST;

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _DepthTex);
				o.screenPos = ComputeScreenPos(o.vertex);//면이 닿는 부분
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {



                
				
				float4 screenPos = float4(i.screenPos.xyz, i.screenPos.w);
				float4 screenPosNorm = screenPos / screenPos.w;


				
				screenPosNorm.x*= _ScreenParams.x/ _ScreenParams.y;
				screenPosNorm.x+= 0.5;
				screenPosNorm.x-= _ScreenParams.x/ _ScreenParams.y/2;


				screenPosNorm.y*=_DepthTex_ST.y;
				screenPosNorm.x*=_DepthTex_ST.y;
				
				screenPosNorm.x+=0.5;
				screenPosNorm.x-=_DepthTex_ST.y/2;
				
				
				float depCol= tex2D(_DepthTex, screenPosNorm.xy);
				
				 fixed4 col=0;
				col.a=1;
				col.r=depCol*2;



                return col;
            }
            ENDCG
        }
    }
}

단 처음에 Rect사이즈를 가져와야 한다

이걸

이렇게 넣으면 끝

내가 이걸 왜 만들었냐 하면 안드로이드에선

정확히는 안드로이드의 OpenGLES3에서 _CameraDepthTexture를 가져올때 문제가 발생하기 때문

그리고 만약 멀티플랫폼을 지원해야 한다면 아래와같은 분기처리를 해줘야 한다

 #if UNITY_IOS || UNITY_STANDALONE
 //기존코드
#else
//커스텀 뎁스
#endif

그리고 당연히 카메라설정도 반영해야 하는데 난 FOV만 바꿔서 FOV만 설정함

using UnityEngine;

public class CameraCopy : MonoBehaviour
{
    void Update()
    {
        var camMain = Camera.main;
        var camThis = GetComponent<Camera>();
        camThis.fieldOfView = camMain.fieldOfView;
    }
}

뎁스 카메라에 이걸 넣어줌

결과물

근데 빌드하고 보니 뎁스 카메라도 안 되더라

찌발

왠지 렌더텍스처를 동적으로 생성하면 될거같기도 한데

이러면 생성할때마다 마테리얼에 하나하나 할당해줄거 생각하니 끔찍해서

결국 분기처리해서 안드로이드쓸때만 작동 안 하게 함

(어차피 아이폰은 된다고)

Shader "Perlin/Noise"
{
    Properties
    {
        [HideInInspector]_MainTex ("Texture", 2D) = "white" {}
		[PowerSlider(4)]_Scale("Scale", Range(0,8192)) = 1000
		_Speed("Speed", Range(0,8)) = 0
		//[HideInInspector]
        _Key("Key", float) = 0
    }
    SubShader
    {
		Tags{
			"RenderType" = "Transparent"
			"Queue" = "Transparent"
            "IgnoreProjector"="True"
		}

        LOD 100
        
		blend srcalpha oneminussrcalpha
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // make fog work
            #pragma multi_compile_fog

            #include "UnityCG.cginc"
            float _Speed;
            float _Key;
            float interpolate(float a0, float a1, float w) {
                /* // You may want clamping by inserting:
                 * if (0.0 > w) return a0;
                 * if (1.0 < w) return a1;
                 */
                return (a1 - a0) * w + a0;
                /* // Use this cubic interpolation [[Smoothstep]] instead, for a smooth appearance:
                 * return (a1 - a0) * (3.0 - w * 2.0) * w * w + a0;
                 *
                 * // Use [[Smootherstep]] for an even smoother result with a second derivative equal to zero on boundaries:
                 * return (a1 - a0) * ((w * (w * 6.0 - 15.0) + 10.0) * w * w * w) + a0;
                 */
            }
            float2 randomGradient(int ix, int iy) {
                // No precomputed gradients mean this works for any number of grid coordinates
                uint w = 8 * (4294967295+1);
                uint s = w / 2; // rotation width
                uint a = ix, b = iy;
                a *= 3284157443; 
                b ^= a << s | a >> w-s;
                b *= 1911520717; 
                a ^= b << s | b >> w-s;
                a *= 2048419325;
                float random = a * (3.14159265 / ~(~0u >> 1)); // in [0, 2*Pi]
                random += _Time.y*_Speed;
                random += _Key;
                float2 v;
                v.x = cos(random); v.y = sin(random);
                return v;
            }
            // Computes the dot product of the distance and gradient vectors.
            float dotGridGradient(int ix, int iy, float x, float y) {
                // Get gradient from integer coordinates
                float2 gradient = randomGradient(ix, iy);

                // Compute the distance vector
                float dx = x - (float)ix;
                float dy = y - (float)iy;

                // Compute the dot-product
                return (dx*gradient.x + dy*gradient.y);
            }
            // Compute Perlin noise at coordinates x, y
            float perlin(float x, float y) {
                // Determine grid cell coordinates
                int x0 = (int)floor(x);
                int x1 = x0 + 1;
                int y0 = (int)floor(y);
                int y1 = y0 + 1;

                // Determine interpolation weights
                // Could also use higher order polynomial/s-curve here
                float sx = x - (float)x0;
                float sy = y - (float)y0;

                // Interpolate between grid point gradients
                float n0, n1, ix0, ix1, value;

                n0 = dotGridGradient(x0, y0, x, y);
                n1 = dotGridGradient(x1, y0, x, y);
                ix0 = interpolate(n0, n1, sx);

                n0 = dotGridGradient(x0, y1, x, y);
                n1 = dotGridGradient(x1, y1, x, y);
                ix1 = interpolate(n0, n1, sx);

                value = interpolate(ix0, ix1, sy);
                return value; // Will return in range -1 to 1. To make it in range 0 to 1, multiply by 0.5 and add 0.5
            }
            float perlin(float2 uv) {
                return perlin(uv.x,uv.y)*0.5+0.5; 
            }
            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                UNITY_FOG_COORDS(1)
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float _Scale;
            
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                UNITY_TRANSFER_FOG(o,o.vertex);
                return o;
            }


            fixed4 frag (v2f i) : SV_Target
            {
                fixed4 col = 1;
                col.rgb = perlin(i.uv*_Scale);
                return col;
            }
            ENDCG
        }
    }
}

내가 포팅한 펄린노이즈임

원문은 https://en.wikipedia.org/wiki/Perlin_noise 에서 가져왔고

포팅만 했을뿐 만든건 Ken Perlin이므로 어떻게 쓰던 알바아님😜

자기가 포팅했다고 하는 노양심짓만 안 해주면 좋을듯

1:1

2:1 크롭

Shader "Ahzkwid/ScreenOverlay"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            sampler2D _MainTex;
            float4 _MainTex_ST;
            float4 _MainTex_TexelSize;
            

            v2f vert (appdata v)
            {
                v2f o;
				o.uv = float4(TRANSFORM_TEX(v.uv, _MainTex),1,1);
				o.vertex.xy = o.uv;
				o.vertex.xy -= 0.5;
				o.vertex.xy *= 2;
				o.vertex.y = -o.vertex.y;
				o.vertex.zw = 1;

                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                fixed2 uv=i.uv;
                
				float screenWid = _ScreenParams.x / _ScreenParams.y;
				float texelWid = _MainTex_TexelSize.z / _MainTex_TexelSize.w;
                if(screenWid>texelWid)
                {
                    uv.x*=screenWid;
			        uv.x -= screenWid / 2;
			        uv.x += texelWid / 2;
                    uv.x/=texelWid;
                }
                else
                {

				    float screenHei = 1/screenWid;
				    float texelHei = 1/texelWid;

                    uv.y*=screenHei;
			        uv.y -= screenHei / 2;
			        uv.y += texelHei / 2;
                    uv.y/=texelHei;
                }

                fixed4 col = tex2D(_MainTex, uv);
                col.a*=all(uv==saturate(uv));
                return lerp(0,col,col.a);
            }
            ENDCG
        }
    }
}

Shader "Skybox/Sample"
{
    Properties
    {
        [NoScaleOffset] _Tex ("Cubemap   (HDR)", Cube) = "grey" {}
    }
    SubShader
    {
        Tags { "Queue"="Background" "RenderType"="Background" "PreviewType"="Skybox" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float3 texcoord : TEXCOORD0;
                UNITY_VERTEX_OUTPUT_STEREO
            };
            
            samplerCUBE _Tex;
            half4 _Tex_HDR;

            v2f vert (appdata v)
            {
                v2f o;
                UNITY_SETUP_INSTANCE_ID(v);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.texcoord = v.vertex.xyz;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                half4 tex = texCUBE (_Tex, i.texcoord);
                fixed3 col = DecodeHDR (tex, _Tex_HDR);
                return half4(col, 1);
            }
            ENDCG
        }
    }
}

샘플코드

쉐이더 짜면서 만들었던 그래프들

사이트는 이곳을 사용했다

https://www.mathway.com/ko/Graph

https://www.desmos.com/calculator?lang=ko 

로그

y=x*x

y=1-x*x

y=sqrt(x)

sqrt(1-x)

y=sqrt(1-abs(x))

안 쓸거 같았는데 의외로 스카이박스 쉐이더 만들때 썼다

y=sqrt(1-abs(x))*x/abs(x)

y=sqrt(x)*sqrt(1-x)

y=sqrt(1-x/2)*sqrt(x*2)

y=sqrt(1-x)*sqrt(x+1)

y=sqrt(x+1)*-sqrt(1-x)

그냥 위에서 +1을 했을뿐

y=sqrt(x+1)*-sqrt(1-x)+1

y=sqrt(x+1)*sqrt(1-x)*x/abs(x)

g=(1+sqrt(5))/2   //황금비

y=(1/(x+g-1))-g+1

위공식에 1-x 했을경우

g=(1+sqrt(5))/2   //황금비

y=(1/(x-g))+g

g=(1+sqrt(5))/2   //황금비

y=abs((1/(abs(x)-g))+g)*x/abs(x)

a=2

b=x*a-1

y=(b*abs(b))/a+1/a

a=2

b=1/a

c=x-b

d=abs(c)

y=sqrt(d)*c/d/sqrt(2)+b

정리가 다 안되었다

일단 sqrt(2)는 앞에 sqrt안에 넣을수 있을듯

y=sqrt(abs(x))*x/abs(x)

a=2

b=x*a-1

y=b*(b*b+1)/a*a+1/a

y=(sqrt(x)-sqrt(1-x)+1)/2

위와는 곡선모양이 조금 다르다

y=(sqrt(1-x)-sqrt(x)+1)/2

위에걸 좌우 뒤집음

y=x*x-x+1

y=-(x*x-x)

y=pow(x,1/x)

y=sqrt((x-0.5)*0.5/(x*x))

y=x*x+sqrt(x)

y=x*x-sqrt(x)+1

y=log(x)+1

y=log(x)*log(x)

y=(log(x)+1)*0.9

대각선 대칭처럼 보이지만 대칭은 아니다

특수한 함수들

sqrt(x*-x*x*-x) = x*x는 동일하다

동일해서 그래프가 겹치다보니 식별하기 쉽게 위의 파란색은 x*-x 로 했다

y=abs(1-abs(x))

y=-x+x/abs(x)

태그: 수학

스티커 쉐이더

팀포의 스프레이 같은걸 생각하면 된다

-프로젝터 기법

간단하면서 확실한 기법이다

장점

  -레이어 구분 가능

  -육안으로 적용된 지역 파악이 쉬움

  -높은 호환성 (기본컴포넌트니까)

  -Orthographic전환이 간편

단점

  -깊이가 너무 깊은면에 투과하는 문제

  -후면 비침문제

더보기

 

 

 스탠다드 에셋에서 프로젝터 쉐이더를 불러와야 하지만 스탠다드 에셋 지원이 끊겼다

 에셋스토어에서 잘 불러오거나 수동으로 만들자

 

 

 

 

 

Standard Assets\Effects\Projectors\Shaders\ProjectorLight.shader

// Upgrade NOTE: replaced '_Projector' with 'unity_Projector'
// Upgrade NOTE: replaced '_ProjectorClip' with 'unity_ProjectorClip'

Shader "Projector/Light" {
	Properties{
		_Color("Main Color", Color) = (1,1,1,1)
		_ShadowTex("Cookie", 2D) = "" {}
		_FalloffTex("FallOff", 2D) = "" {}
	}

		Subshader{
			Tags {"Queue" = "Transparent"}
			Pass {
				ZWrite Off
				ColorMask RGB
				Blend DstColor One
				Offset -1, -1

				CGPROGRAM
				#pragma vertex vert
				#pragma fragment frag
				#pragma multi_compile_fog
				#include "UnityCG.cginc"

				struct v2f {
					float4 uvShadow : TEXCOORD0;
					float4 uvFalloff : TEXCOORD1;
					UNITY_FOG_COORDS(2)
					float4 pos : SV_POSITION;
				};

				float4x4 unity_Projector;
				float4x4 unity_ProjectorClip;

				v2f vert(float4 vertex : POSITION)
				{
					v2f o;
					o.pos = UnityObjectToClipPos(vertex);
					o.uvShadow = mul(unity_Projector, vertex);
					o.uvFalloff = mul(unity_ProjectorClip, vertex);
					UNITY_TRANSFER_FOG(o,o.pos);
					return o;
				}

				fixed4 _Color;
				sampler2D _ShadowTex;
				sampler2D _FalloffTex;

				fixed4 frag(v2f i) : SV_Target
				{
					fixed4 texS = tex2Dproj(_ShadowTex, UNITY_PROJ_COORD(i.uvShadow));
					texS.rgb *= _Color.rgb;
					texS.a = 1.0 - texS.a;

					fixed4 texF = tex2Dproj(_FalloffTex, UNITY_PROJ_COORD(i.uvFalloff));
					fixed4 res = texS * texF.a;

					UNITY_APPLY_FOG_COLOR(i.fogCoord, res, fixed4(0,0,0,0));
					return res;
				}
				ENDCG
			}
	}
}

 

 

Standard Assets\Effects\Projectors\Shaders\ProjectorMultiply.shader

// Upgrade NOTE: replaced '_Projector' with 'unity_Projector'
// Upgrade NOTE: replaced '_ProjectorClip' with 'unity_ProjectorClip'

Shader "Projector/Multiply" {
	Properties{
		_ShadowTex("Cookie", 2D) = "gray" {}
		_FalloffTex("FallOff", 2D) = "white" {}
	}
		Subshader{
			Tags {"Queue" = "Transparent"}
			Pass {
				ZWrite Off
				ColorMask RGB
				Blend DstColor Zero
				Offset -1, -1
		 
				CGPROGRAM
				#pragma vertex vert
				#pragma fragment frag
				#pragma multi_compile_fog
				#include "UnityCG.cginc"

				struct v2f {
					float4 uvShadow : TEXCOORD0;
					float4 uvFalloff : TEXCOORD1;
					UNITY_FOG_COORDS(2)
					float4 pos : SV_POSITION;
				};

				float4x4 unity_Projector;
				float4x4 unity_ProjectorClip;

				v2f vert(float4 vertex : POSITION)
				{
					v2f o;
					o.pos = UnityObjectToClipPos(vertex);
					o.uvShadow = mul(unity_Projector, vertex);
					o.uvFalloff = mul(unity_ProjectorClip, vertex);
					UNITY_TRANSFER_FOG(o,o.pos);
					return o;
				}

				sampler2D _ShadowTex;
				sampler2D _FalloffTex;

				fixed4 frag(v2f i) : SV_Target
				{
					fixed4 texS = tex2Dproj(_ShadowTex, UNITY_PROJ_COORD(i.uvShadow));
					texS.a = 1.0 - texS.a;

					fixed4 texF = tex2Dproj(_FalloffTex, UNITY_PROJ_COORD(i.uvFalloff));
					fixed4 res = lerp(fixed4(1,1,1,0), texS, texF.a);

					UNITY_APPLY_FOG_COLOR(i.fogCoord, res, fixed4(1,1,1,1));
					return res;
				}
				ENDCG
			}
	}
}

 

Shader error in 'ProjectorMultiply': Parse error: syntax error, unexpected '-', expecting TVAL_VARREF or TVAL_NUMBER at line 15

문제가 발생하면 해당영역의 '-'글자를 수동으로 쳐주자

 

 

 

Cookie부분이 _MainTex와 동등한부분이다

 

 

아까만든 프로젝터에 마테리얼을 할당한다

 

 

그리고 투사하면...

 

 

 

개박살난다

 

표시영역보다 메쉬가 크면 나머지를 WrapMode에 따라 배치하기 때문

 

 

가장자리를 흰색으로 처리하는 방법

 

 WrapMode를 Clamp로 바꿔주자

이러면 이렇게 가장자리가 늘어지게 되는데 가장자리를 흰색으로 처리해준다

 

 

 

 

 

쉐이더를 수정하는 방법

fixed4 uv = UNITY_PROJ_COORD(i.uvShadow);
fixed4 texS = tex2Dproj(_ShadowTex, uv);
texS.a = 1.0 - texS.a;
if (!all(uv.xy==saturate(uv.xy)))
{
    texS.rgb = 1;
}

위 코드를 texS에 적용시킨다

 

 

적용된 모습

 

 

 

 

 

 

 

 

 

 

 

쉐이더 픽셀 깨짐현상

계산시 색이 바뀌는 구간에서 전혀 다른색이 들어가는 현상이다

각종 보간효과들이 들어가면서 발생하는 현상이다

사용된 연산식은 이렇다

int _BoardSize = 8;
float2 uv = (floor(i.uv * _BoardSize) + 0.5) / _BoardSize;
col= tex2D(_MainTex, uv);

보간효과들을 꺼주면 된다

둘중하나라도 켜져있으면 발생하니 주의

수정된모습

밉맵이야 그렇다 쳐도 Bilinear연산이 빠지는건 타격이 꽤 크다

경우에 따라 밉맵만 꺼도 티가 잘 안나는 경우가 있으니 상황에 따라 맞게 사용할것