어영부영TA (AI신과함께)

유니티는 프레임 디버거를 이용하여 매 프레임마다 그려지는 게임오브젝트의 순서를 눈으로 확인할수 있다.

어떤것부터 그리는지 알수없다.

그려지는 순서에 따라 오브젝트가 가려질수 있다.

불투명 오브젝트를 먼저 그린다.

반투명 오베즉트는 나중에 그린다.

반투명 오브젝트끼리는 뒤에서부터 그린다.

알파 소팅을 써봤자 완벽하게 앞뒤를 제대로 판정할수 없으니, 알파를 썼을때 문제는 일어난다.

알파 블렌딩을 사용하였을때에는 Zwrite를 하지 않는다.

이문제를 해결하기 위하여 고민이 필요하다.

z Buffer

앞뒤 판정을 위해서 각 픽셀마다 기준으로 가장 가까운 오브젝트의 깊이값이 저장되어있는 데이터

OverDraw

그려진 이미지위에 덧그려지는 것

Alpha sorting

멀리 있는것부터 차례대로 그리는 것

Deferred Rendering

반투명을 처리할수 없다.(할수있지만 어렵다?)

Foward Rendering

Opaque

불투명

Transparent

반투명

알파 구현1

Shader "Custom/108_alpha"
{
Properties
{
_MainTex ("Albedo (RGB)", 2D) = "white" {}
}

이미지는 옵션을 clamp 두는것이 좋다.
그래야 반복되는 부분의 끝부분이 보인다던가 하는
문제를 해결할수 있다.

SubShader
{
Tags { "RenderType"="Transparent" "Queue"= "Transparent"}
cull off

CGPROGRAM
#pragma surface surf Lambert alpha:fade

cull off 양면구현

sampler2D _MainTex;

struct Input
{
float2 uv_MainTex;
};

void surf (Input IN, inout SurfaceOutput o)
{
fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}
ENDCG

}
FallBack "Legacy Shaders/Transparent/VertexLit" //"Diffuse"
}

Diffuse로 놓으면 폴리곤 형태 그대로의 그림자가 나오게 된다.
이부분은 그림자를 끄는것이고 이를 사실 완전한 구현이라 할수없다.
그래서 AlphaTest(Cutout) 쉐이더를 사용한다.

Legacy Shaders/Transparent/Diffuse 이렇게해도 결과는 같다.

알파 구현2
(알파된 오브젝트 그림자 구현)

Shader "Custom/109_alpha_cutout"
{
Properties
{
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Cutoff ("Alpha cutoff", Range(0,1))=0.5
}

하나는 알파테스트이고,
하나는 그냥 트랜스파렌트이다.
둘다 적용이 가능하다.

SubShader
{

Tags { "RenderType"="TransparentCutout" "Queue"= "AlphaTest"}
cull off

CGPROGRAM
#pragma surface surf Lambert alphatest:_Cutoff

SubShader
{
Tags { "RenderType"="Transparent" "Queue"= "Transparent"}

cull off

CGPROGRAM
#pragma surface surf Lambert alpha:fade

sampler2D _MainTex;

struct Input
{
float2 uv_MainTex;
};

void surf (Input IN, inout SurfaceOutput o)
{
fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Legacy Shaders/Transparent/Cutout/VertexLit"

void surf (Input IN, inout SurfaceOutput o)
{
fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Legacy Shaders/Transparent/Cutout/VertexLit"

RampTexture

Shader "Custom/104_RampTexture"
{
Properties
{

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

}

SubShader
{
Tags { "RenderType"="Opaque" }


CGPROGRAM
#pragma surface surf warp noambient

sampler2D _MainTex;
sampler2D _RampTex;

warp관련되서 계속 오류가 있었는데, 이유를 찾지못하다가
알고보니, 밑에 Lightingwarp을 Lightingtoon으로 해놨었음.
라이트이름만인줄알았지만 라이트설정을 받을때도 쓴다.

struct Input
{
float2 uv_MainTex;
};

void surf (Input IN, inout SurfaceOutput o)
{

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}

float4 Lightingwarp( SurfaceOutput s,float3 lightDir, float atten)
{
float ndotl = dot(s.Normal,lightDir); //*0.5+0.5;
//float4 ramp = tex2D(_RampTex, float2(0.1,0.1));
float4 ramp = tex2D(_RampTex, float2(ndotl,0.5));
return ramp;

}

ENDCG

}
FallBack "Diffuse"

outline

Shader "Custom/101_outline-2pass"
{
Properties
{

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

}

SubShader
{
Tags { "RenderType"="Opaque" }

cull front

//1st pass
CGPROGRAM
#pragma surface surf Nolight vertex:vert noshadow noambient
<![if !supportLineBreakNewLine]>
<![endif]>

//vertex:vert 버텍스 함수 시작임을 나타낸다.
//noshadow: 만약 그림자 패스에도 확장된 버텍스 영향을 주고 싶다면,
addshadow라고 써준다.
//noambient : 앰비언트 없애고
//nolight : 빛도 없애고

sampler2D _MainTex;

void vert(inout appdata_full v)


{
//float4 vertex : POSITION; // 모든 베텍스 쉐이더에 있음.
//float4 tangent : TANGENT; // appdata_full과 tan에 있다.
//float3 normal : NORMAL; // 모든 베텍스 쉐이더에 있음..
//float4 texcoord : TEXCOORD0; // 모든 베텍스 쉐이더에 있음.
//float4 texcoord1 : TEXCOORD1;//appdata_full에만 있다.
//float4 texcoord2 : TEXCOORD2; //appdata_full에만 있다.
//float4 texcoord3 : TEXCOORD3; //appdata_full에만 있다.
//float4 color : COLOR; //appdata_full에만 있다.
//UNITY_VERTEX_INPUT_INSTANCE_ID // 모든 베텍스 쉐이더에 있음.

//v.vertex.y = v.vertex.y + 0.1; // 이렇게 하면 모든 버텍스가 y축으로 0.1만큼 이동됨.(실제 오브젝트가 이동은 아님)
//v.vertex.y+= 0.1; 라고 써도 위랑 같음(+= 띄워 쓰면 안됨.)

//v.vertex.xyz = v.vertex.xyz +v. normal.xyz; // 버텍스가 확장된다.
//v.vertex.xyz+= v.vertex.xyz; 위랑 같은거임

v.vertex.xyz+= v.normal.xyz*0.005; // 버텍스가 확장된다.


}

//appdata_base:position, normal and one texture coordinates
: 위치, 노멀, 텍스쳐 좌표계

//appdata_tan: position, tangent, normal and one texture coordinates
: 위치, 탄젠트, 노멀, 1개의 텍스쳐 좌표계

//appdata_full: position, tangent, normal, four texture coordinates and color
:위치, 탄젠트, 노멀, 4개의 텍스쳐 좌표계와 버텍스 컬러

//3가지중 당연히 base가 가장 가벼움.

struct Input
{
float4 color:COLOR; // 필요없는데 아무것도 없으면 문제가 생기기 때문에 아무거나 넣은거.
};

void surf (Input IN, inout SurfaceOutput o)
{
// 아무것도 없어도 문제가 안생김.
// Albedo가 없는 이유: 라이팅 계산조차 필요하지 않기 때문에 컬러를 넣을 필요가 없음. 검은색이니깐
}

float4 LightingNolight( SurfaceOutput s,float3 lightDir, float atten)
{
return float4(0,0,0,1);
}

ENDCG

cull back

//2nd pass
CGPROGRAM
#pragma surface surf Lambert

sampler2D _MainTex;

struct Input
{
float2 uv_MainTex;
};

void surf (Input IN, inout SurfaceOutput o)
{

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}
ENDCG

}
FallBack "Diffuse"
}

끊어지는 음영
카툰

Shader "Custom/102_IF_CUT_shadow"
{
Properties
{

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

}
SubShader
{
Tags { "RenderType"="Opaque" }

cull back

//2nd pass
CGPROGRAM
#pragma surface surf Toon noambient

sampler2D _MainTex;

struct Input
{
float2 uv_MainTex;
};

void surf (Input IN, inout SurfaceOutput o)
{

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}

float4 LightingToon( SurfaceOutput s,float3 lightDir, float atten)
{
float ndotl = dot(s.Normal,lightDir);//*0.5+0.5; //half Lambert로 만든거임.

if (ndotl>0.7)
{
ndotl=1;
}
else if (ndotl>0.4)
{
ndotl=0.3;
}
else
{
ndotl=0;
}

//return ndotl; 텍스쳐 없이 컬러 음영만 테스트시
float4 final;
final.rgb=s.Albedo * ndotl *_LightColor0.rgb;
final.a=s.Alpha;

return final;
}

ENDCG

}
FallBack "Diffuse"

Fresnel outline

Shader "Custom/102_IF_CUT_shadow"
{
Properties
{

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

}
SubShader
{
Tags { "RenderType"="Opaque" }

cull back

//2nd pass
CGPROGRAM
#pragma surface surf Toon noambient

sampler2D _MainTex;

struct Input
{
float2 uv_MainTex;
};

void surf (Input IN, inout SurfaceOutput o)
{

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}

float4 LightingToon( SurfaceOutput s,float3 lightDir, float3 viewDir, float atten)
{
float ndotl = dot(s.Normal,lightDir);//*0.5+0.5; //half Lambert로 만든거임.

if (ndotl>0.7)
{
ndotl=1;
}
else if (ndotl>0.4)
{
ndotl=0.3;
}
else
{
ndotl=0;
}

float rim = abs(dot(s.Normal,viewDir));
if(rim>0.3)
{
rim =1;
}
else
{
rim =-1;
}

else 부분이 0이 아닌 이유는 최종적으로 ambient color가 더해지면서
검은색 선이 ambient color로 밝아지기 때문이다. 그영향을 없애려고
마이너스-1이 들어간것입니다.

//return ndotl; 텍스쳐 없이 컬러 음영만 테스트시
float4 final;
final.rgb=s.Albedo * ndotl *_LightColor0.rgb;
final.a=s.Alpha;

return final;
}

ENDCG

}
FallBack "Diffuse"

프레넬 공식

Shader "Custom/20_Lambert_lim1"
{
Properties
{
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_RimColor ("RimColor", Color) = (1,1,1,1)
_RimPower ("RimPower", Range(1,10)) = 3

}

SubShader
{
Tags { "RenderType"="Opaque" }

CGPROGRAM

#pragma surface surf Lambert noambient


sampler2D _MainTex;

struct Input
{
float2 uv_MainTex;
float3 viewDir; // 버텍스가 카메라 방향을 보는 방향
};

SubShader
{
Tags { "RenderType"="Opaque" }

CGPROGRAM

#pragma surface surf Lambert noambient


sampler2D _MainTex;
float4 _RimColor;
float _RimPower;

struct Input
{
float2 uv_MainTex;
float3 viewDir; // 버텍스가 카메라 방향을 보는 방향
};

void surf (Input IN, inout SurfaceOutput o)
{

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

float rim = dot(o.Normal, IN.viewDir);

o.Emission = pow(1- rim, 3);

o.Albedo = c.rgb;
//0으로 놓고 하면 까만 초기 상태가 된다.
o.Alpha = c.a;
}

o.Emission = 1- rim 이렇게 하면 그래프로 보면 직각이된다.


그래서 pow(exponet, 지수)를 써서 그래프가 산모양으로 되게 만들어서
림 굵기를 얇게 하는것이다.

pow연산은 비교적 무겁다.

void surf (Input IN, inout SurfaceOutput o)
{

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

o.Albedo = 0;//0으로 놓고 하면 까만 초기 상태가 된다.
float rim = dot(o.Normal, IN.viewDir);
o.Emission = pow(1- rim, _RimPower)*_RimColor.rgb;
o.Alpha = c.a;
}

ENDCG
}
FallBack "Diffuse"
}

ENDCG
}
FallBack "Diffuse"
}

SurfaceOutput기본에

SubShader
{
Tags { "RenderType"="Opaque" }

CGPROGRAM


#pragma surface surf Test noambient

sampler2D _MainTex;
sampler2D _BumpMap;

struct Input
{
float2 uv_MainTex;
float2 uv_BumpMap;
};


void surf (Input IN, inout SurfaceOutput o)
{
fixed4 c = tex2D (_MainTex, IN.uv_MainTex);

o.Albedo = c.rgb;
o.Normal = UnpackNormal(tex2D(_BumpMap,IN.uv_BumpMap));
o.Alpha = c.a;
}

//#pragma surface surf Lambert noambient (Lambert를 test로 바꿔서 해봄. 커스텀을 만들기 위함인듯)

noambient는 엠비언트를 제거하여 lambert를 확실하게 보기 위함이라고 함

라이트를 넣어서 구현

float4 LightingTest (SurfaceOutput s, float3 lightDir, float atten)
{

float ndotl = dot(s.Normal, lightDir)*0.5+0.5; // halp Lambert 연산 만들기
return ndotl;

}

ENDCG
}

float4 LightingTest (SurfaceOutput s, float3 lightDir, float atten)
Test라는 라이팅을 float4로 셋팅하겠다.(SurfaceOutput구조체를 쓰겠다 그리고 s라고 하겠다.
float3으로 조명을셋팅하겠다. float atten으로 감쇠조명을 만들겠다.)

//Lighting+Test 붙여야함.

// return 값이 있어야 결과가 출력됨. ndotl=N(노멀)+L(라이트)+dot(닷)
//float ndotl = dot(s.Normal, lightDir);
//float ndotl = saturate(dot(s.Normal, lightDir)); //saturate 함수는 0보다 낮은 값은 0으로 1보다 높은 값은 1로
//float ndotl = max(0.2,dot(s.Normal, lightDir)); //max 한쪽의 값을 0.2으로 하면, 0.2보다 작은 다른쪽 값을 무조건 0으로 출력
//float ndotl = dot(s.Normal, lightDir)*0.5+0.5; // halp Lambert 연산 만들기

여기에 출력되는 return ndotl; 에 return ndotl+0.5; 하면 더 밝아진다.

라이팅구조

램버트, 블린퐁, 스탠다드 3가지가 존재( 스페큘러 컬러를 조정하는것도 추가로 하나 있음.)

물리기반쉐이더

standard shader

struct SurfaceOutputstandard
{
fixed Albedo; 물체의 색상
fixed Normal; 노멀맵
fixed Emission; 빛영향받지 않는 색상
fixed Metalic; 재질금속
fixed Smoothness; 재질의 거침
fixed Occlusion; 오클루젼
fixed Alpha; 알파
};

PBS
(pysically based shader)

SurfaceOutputstandard
SurfaceOutputstandardStandardSpecular

기본쉐이더

Lambert / Blinn phong

struct SurfaceOutput
{
half3 Albedo; 물체의 색상
half3 Normal; 노멀맵
half3 Emission; 빛영향받지 않는 색상
half Specular; 하이라이트
half Gloss; 스페큘러 강도
half Alpha; 알파
};

버텍스컬러 출력하기

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


}

SubShader
{
Tags { "RenderType"="Opaque" }
LOD 200

CGPROGRAM

#pragma surface surf Standard noambient


sampler2D _MainTex;

struct Input
{
float2 uv_MainTex;
float4 color:COLOR; // 컬러를 추가하였음.
};

void surf (Input IN, inout SurfaceOutputStandard o)
{

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
//o.Albedo = c.rgb;
//o.Albedo = IN.color.rgb; //이렇게 해도됨. 다만 그림자가 진다.
//o.Albedo = c.rgb+IN.color.rgb; //이러면 버텍스 컬러와 이미지가 같이 나오겠지.
//o.Albedo = c.rgb*IN.color.rgb; //이러면 버텍스 컬러와 이미지가 곱해지니깐 검은곳은 어둡게(검은곳은 0이니깐).
이렇게하면 텍스쳐 없는 오클루젼을 만들수 있다.(라이트맵처럼)
o.Emission = IN.color.rgb; // Emission으로 출력
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}

여러장 버텍스 텍스쳐사용

{
Properties
{
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_MainTex2 ("Albedo (RGB)", 2D) = "white" {}
_MainTex3 ("Albedo (RGB)", 2D) = "white" {}
_MainTex4 ("Albedo (RGB)", 2D) = "white" {}


}

SubShader
{
Tags { "RenderType"="Opaque" }


CGPROGRAM

#pragma surface surf Standard noambient


sampler2D _MainTex;
sampler2D _MainTex2;
sampler2D _MainTex3;
sampler2D _MainTex4;

struct Input
{
float2 uv_MainTex;
float2 uv_MainTex2;
float2 uv_MainTex3;
float2 uv_MainTex4;
float4 color:COLOR;



};
<![if !supportLineBreakNewLine]>
<![endif]>

void surf (Input IN, inout SurfaceOutputStandard o)
{

fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
fixed4 d = tex2D (_MainTex2, IN.uv_MainTex2);
fixed4 e = tex2D (_MainTex3, IN.uv_MainTex3);
fixed4 f = tex2D (_MainTex4, IN.uv_MainTex4);

o.Albedo = lerp(c.rgb, d.rgb, IN.color.r);
o.Albedo = lerp(o.Albedo, e.rgb, IN.color.g);
o.Albedo = lerp(o.Albedo, f.rgb, IN.color.b);

o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}

흑백이미지

void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo =(c.r+c.g+c.g)/3;
o.Alpha = c.a;
}

UV 밀기

void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex+0.5);
o.Albedo = c.rgb;
o.Alpha = c.a;
}

lerp함수

_MainTex ("텍스쳐1", 2D) = "white { }
_MainTex2 ("텍스쳐2", 2D) = "white { }

Properties

lerp(X,Y,s)
X,Y는 반드시 float, float1,float2,float3,float4형태
s는 float 한자리수로 0~1이다.

sampler2D _MainTex;
sampler2D _MainTex2;

void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
fixed4 d = tex2D (_MainTex, IN.uv_MainTex2);
o.Albedo =lerp(c.rgb, d.rgb, 0.5);
o.Alpha = c.a;
}

2개의 텍스쳐를 혼합
선형 보간(그라데이션)

lerp(X, Y, s) s는 float(숫자)이어야 합니다.

0.5로 인하여 이미지가 반반씩 섞이게 됩니다.

void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
fixed4 d = tex2D (_MainTex, IN.uv_MainTex2);
o.Albedo =lerp(c.rgb, d.rgb, c.a);
o.Alpha = c.a;
}

알패 채널을 이용하여 두가지의 텍스쳐를 나오게 하는 방법.

o.Albedo =lerp(c.rgb, d.rgb, 1-c.a) 하면 반대로 뒤집힌다.
위엣것이랑 같은게 된다.o.Albedo =lerp(d.rgb, c.rgb, c.a)

lerp함수 비슷한거

void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
fixed4 d = tex2D (_MainTex, IN.uv_MainTex2);
o.Albedo = c.rgb * d.rgb;
o.Alpha = c.a;
}

*으로 곱해줌.

o.Albedo = c.rgb * (d.rgb+_lerptest);
위에 프로버티를 그대로 적용하면 컬러가 섞인다.

변수

void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color

float4 test = float4(1,0,0,1)

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

o.Alpha = c.a;
}

빨란색이 출력

o.Albedo = test.rgb;라고 써야 맞다. 이유는 rgb만 사용하기 때문이다.

rgb앞에 마침표는 내부에 들어갈 값이다.

.rgb라고 쓰면 float3으로 변경되는것이다.

float4 test = float4(1,0,0,1)위치가 위어야 정상으로 출력이된다.

void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color

float K = 1;
float G = float2(0.5,0);
float BB = float3(1,0,1);

fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = float3(K,G,BB)

o.Alpha = c.a;
}

핑크 컬러 출력

o.Albedo = float3(0.2,G,1)이런식으로 숫자를 넣어도 된다.