한국어 쉐이더 테크닉 자료 모음집 1
간단 요약: 여러가지 테크닉적 렌더 표현법 자료 링크: https://docs.google.com/document/d/1gpVK8AfQkiUS6-Y6v4JiR0Bp9grjPNOHo5E-lekUZjc/edit 태그: Cartoon, Core, Hair, NPR, Pipeline, Reality, Shader, Shadow, Stencil, Unity, Water, ZTest
번역 본문
Surface Shader 정리 보기 -> 문서개요 표시를 누르시면 더 쉽게 찾으실 수 있습니다.
이방성 스펙큘러(AnisotropicSpec)
Shader "Jinho/AnisotropicSpec" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Albedo (RGB)", 2D) = "white" {} [Normal]_Normal("Normal", 2D) = "bump"{} _NormalPow("NormalPow", Range(0, 3)) = 1
_AnisoAngleX("AnisoAngle", float) = 0
_AnisoAngleY("AnisoAngle", float) = 0
_AnisoAngleZ("AnisoAngle", float) = 0
_AnisoOffset("AnisoOffset", Range(-1, 1)) = -0.2
[powslide(100)]_AnisoPow("AnisoPow", Range(0, 100)) = 1
[HDR]_SpecColor2("SpecColor2", Color) = (1, 1, 1, 1)
}
SubShader {
Tags { "RenderType"="Opaque" }
LOD 200
cull off
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf NoLighting fullforwardshadows
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 3.0
sampler2D _MainTex;
sampler2D _Normal;
struct Input {
float2 uv_MainTex;
float2 uv_Normal;
};
fixed4 _Color;
half _NormalPow;
half _AnisoAngleX;
half _AnisoAngleY;
half _AnisoAngleZ;
half _AnisoOffset;
half _AnisoPow;
half3 _SpecColor2;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
void surf (Input IN, inout SurfaceOutput o) {
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Normal = lerp(o.Normal, UnpackNormal(tex2D(_Normal, IN.uv_Normal)), _NormalPow);
o.Albedo = c.rgb;
o.Alpha = c.a;
}
//이방성 하이라이트 계산
fixed4 LightingNoLighting(SurfaceOutput s, fixed3 lightDir, fixed3 viewDir, fixed atten)
{
fixed4 c;fixed3 h = normalize(normalize(lightDir) + normalize(viewDir)); //라이트각도, 뷰각도 노멀라이즈
half HdotA = dot(normalize(s.Normal + half3(_AnisoAngleX, _AnisoAngleY, _AnisoAngleZ)), h); //노멀 + 커스텀앵글을 라이트, 뷰각도노멀라이즈와 내적
half aniso = max(0, sin(radians(HdotA + _AnisoOffset) * 180));
c.rgb = saturate(pow(aniso, _AnisoPow)) * _SpecColor2;
//c.rgb = s.Albedo;
c.a = s.Alpha;
return c;
}
ENDCG
}
FallBack "Diffuse"
}
노멀맵 블렌딩
// IN.worldNormal을 그냥 Lerp할 경우 노멀맵이 제대로 처리 안되므로 WorldNormalVector 로 한번 정의한 뒤 사용할 것
Shader "Custom/AgeiaShader" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Albedo (RGB)", 2D) = "white" {} [Normal]_Normal("Normal", 2D) = "bump"{} _NormalPow("NormalPow", Range(0, 5)) = 1 _UVScale("UVScale", float) = 1 } SubShader { Tags { "RenderType"="Opaque" } LOD 200
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf Lambert fullforwardshadows
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 3.0
sampler2D _MainTex;
sampler2D _Normal;
struct Input
{
float2 uv_MainTex;
float2 uv_Normal;
half3 worldPos;
half4 worldNormal;
INTERNAL_DATA
};
fixed4 _Color;
half _NormalPow;
half _UVScale;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
void surf (Input IN, inout SurfaceOutput o)
{
float3 n = WorldNormalVector(IN, o.Normal);
half3 WorldPos = IN.worldPos * _UVScale;
half2 WorldUVTop = half2(WorldPos.x, WorldPos.z);
fixed3 AlbedoTop = tex2D (_MainTex, WorldUVTop);
half3 NormalTop = UnpackNormal(tex2D(_Normal, WorldUVTop));half2 WorldUVFront = half2(WorldPos.x, WorldPos.y);
고정3 AlbedoFront = tex2D (_MainTex, WorldUVFront);
half3 NormalFront = UnpackNormal(tex2D(_Normal, WorldUVFront));
half2 WorldUVSide = half2(WorldPos.z, WorldPos.y);
고정3 AlbedoSide = tex2D (_MainTex, WorldUVSide);
half3 NormalSide = UnpackNormal(tex2D(_Normal, WorldUVSide));
half3 AlbedoFinal = lerp(AlbedoTop, AlbedoFront, abs(n.z));
half3 AlbedoFinal2 = lerp(AlbedoFinal, AlbedoSide, abs(n.x));
half3 NormalFinal = lerp(NormalTop, NormalFront, abs(n.z));
half3 NormalFinal2 = lerp(NormalFinal, NormalSide, abs(n.x));
//o.알베도 = abs(n.y);
o.Albedo = AlbedoFinal2 * _Color;
o.Normal = lerp(o.Normal, NormalFinal2, _NormalPow);
}
ENDCG
}
대체 "확산"
}
버텍스 색상을 맞이합니다
- 구조체 데이터에 Color:COLOR;
- 표면 데이터에 IN.Color;
페페 데이터
float2 offset = ParallaxOffset((h * 1 + 0.25), _Parallax, IN.viewDir); 고정4 c = tex2D (_MainTex, IN.uv_MainTex + 오프셋) * _Color;
반사렉션 프로브 데이터 Ver.2 (리플렉션 Mipmap, 반사렉션 블렌딩 지원) 셰이더 "Custom/TestReflectionLOD" { 속성 { _Color ("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _ReflectionLOD("반사LOD", 범위(0, 7)) = 1 [HideInInspector]_unity_SpecCube0("Cube", CUBE) = "unity_SpecCube0"{} //인스펙터에서 건드리지 말 것. [HideInInspector]_unity_SpecCube1("Cube", CUBE) = "unity_SpecCube1"{} //인스펙터에서 건드리지 말 것. _ReflPow("ReflPow", float) = 1 _ReflMul("ReflMul", float) = 1 } 서브셰이더 { 태그 { "RenderType"="불투명" } LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 Lambert fullforwardshadows
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
샘플러2D _MainTex;
구조체 입력 {
float2 uv_MainTex;
half3 worldRefl; //WorldReflectionVector 데이터가 사용됩니다.
내부_데이터};
고정4 _색상;
절반 _ReflectionLOD;
SamplerCUBE _unity_SpecCube0;
SamplerCUBE _unity_SpecCube1;
절반 _ReflPow;
절반 _ReflMul;
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
void Surf (입력 IN, 입력 SurfaceOutput o) {
half3 Reflection1 = texCUBElod(_unity_SpecCube0, float4(WorldReflectionVector(IN, o.Normal), _ReflectionLOD));
half3 Reflection2 = texCUBElod(_unity_SpecCube1, float4(WorldReflectionVector(IN, o.Normal), _ReflectionLOD));
half3 ReflFianl = lerp(Reflection2, Reflection1, unity_SpecCube0_BoxMin.w);
o.Albedo = pow(ReflFianl, _ReflPow) * _ReflMul;
o.알파 = 1;
}
ENDCG
}
대체 "확산"
} 반사렉션 프로브 데이터 Ver.1 (리플렉션 블렌딩만 지원)
셰이더 "Ageia/SimpleReflectionProbe" { 속성 { _Color ("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} [Normal]_Normal("Normal", 2D) = "범프"{} _NormalPow("NormalPow", 범위(0, 3)) = 1 _Metallic("금속성", 범위(0, 1)) = 1 } 서브셰이더 { 태그 { "RenderType"="불투명" } LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 CumstomLighing fullforwardshadows
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
샘플러2D _MainTex;
Sampler2D _Normal;
구조체 입력 {
float2 uv_MainTex;
half2 uv_Normal;
half3 viewDir;
half3 worldRefl; //WorldReflectionVector 데이터가 사용됩니다.
내부_데이터
//worldRefl 데이터를 가져오기 위해 해당 데이터 구조를 필요로 함.
};
고정4 _색상;
절반 _NormalPow;
절반 _NormalPow2;
하프 _메탈릭;// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
void Surf (입력 IN, 입력 SurfaceOutput o) {
half3 NormalTest = UnpackNormal(tex2D(_Normal, IN.uv_Normal));
o.Normal = lerp(o.Normal, NormalTest, _NormalPow);
//단순ReflectionMap
half3 Reflection1 = UNITY_SAMPLE_TEXCUBE(unity_SpecCube0, WorldReflectionVector(IN, o.Normal)) * unity_SpecCube0_HDR.r;
//unity_SpecCube0_HDR.r : 오류렉션 큐의 Intensity값.
half3 Reflection2 = UNITY_SAMPLE_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0, WorldReflectionVector(IN, o.Normal)) * unity_SpecCube0_HDR.r;
//Reflection2는 다른 반사렉션과 함께 보간을 처리합니다. 불필요한 경우에는 제거하시기 바랍니다.
half3 ReflectionFinal = lerp(Reflection2, Reflection1, unity_SpecCube0_BoxMax.w * unity_SpecCube0_BoxMin.w);
//unity_SpecCube0_BoxMin.w : 방해의 반사렉션 프로브를 보간합니다.
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = lerp(c.rgb, 0, _Metallic);
//o.Emission = pow(NdotV * 0.5 + 0.5, 20);
o.Emission = lerp(0, ReflectionFinal, _Metallic);
o.알파 = c.a;
}
half4 LightingCumstomLighing(SurfaceOutput s, half3 lightDir, half atten)
{
반4c;
c.rgb = s.알베도;
c.a = s.알파;
c를 반환;
}
ENDCG
}
대체 "확산"
}
빌보드가 더
셰이더 "Ageia/Bilboard" { 속성{ _Color("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _Glossiness("부드러움", 범위(0,1)) = 0.5 _Metallic("금속성", 범위(0,1)) = 0.0 }
서브셰이더{
태그{ "Queue" = "투명" "RenderType" = "투명" "DisableBatching" = "True" }
LOD 200
CGPROGRAM
#pragma 표면 서핑 표준 fullforwardshadows 정점:vert 알파:페이드
샘플러2D _MainTex;
구조체 입력 {
float2 uv_MainTex;
};반_광택;
하프 _메탈릭;
고정4 _색상;
무효 vert(inout appdata_full v, out 입력 o)
{
UNITY_INITIALIZE_OUTPUT(입력, o);
//객체 크기 적용
v.vertex.xy *= float2(length(unity_ObjectToWorld._m00_m10_m20), length(unity_ObjectToWorld._m01_m11_m21));
// 카메라 기본 벡터를 얻습니다.
float3 앞으로 = -normalize(UNITY_MATRIX_V._m20_m21_m22);
float3 up = 정규화(UNITY_MATRIX_V._m10_m11_m12);
float3 right = 정규화(UNITY_MATRIX_V._m00_m01_m02);
// 카메라를 향하도록 회전
float4x4 회전 매트릭스 = float4x4(오른쪽, 0,
위로, 0,
앞으로, 0,
0, 0, 0, 1);
v.vertex = mul(v.vertex,rotationMatrix);
v.normal = mul(v.normal,rotationMatrix);
// 월드 변환 표면 셰이더에 대한 객체 실행 취소가 적용됩니다.
v.vertex.xyz = mul((float3x3)unity_WorldToObject, v.vertex.xyz);
v.normal = mul(v.normal, (float3x3)unity_ObjectToWorld);
}
void Surf(입력 IN, inout SurfaceOutputStandard o) {
// 알베도는 색상별로 착색된 텍스처에서 나옵니다.
고정4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color;
o.알베도 = c.rgb;
// 금속성과 부드러움은 슬라이더 변수에서 나옵니다.
o.메탈릭 = _메탈릭;
o.부드러움 = _광택;
o.알파 = c.a;
}
ENDCG
}
FallBack "투명/VertexLit"
}
반사큐브 색상
o.Albedo = UNITY_SAMPLE_TEXCUBE(unity_SpecCube0, o.Normal); 이더 전처리 이더 전처리 변경
- 불리언 방식은 거의 비슷하게 처리됩니다.
- Enum일 경우 나머지는 다 서명하고 필요한 것만 킬 것입니다.
this.ChaMaterial[i].material.DisableKeyword("BOOLEAN_6BE23A54_ON"); this.ChaMaterial[i].material.EnableKeyword("BOOLEAN_6BE23A54_ON");
이더 전 처리
셰이더 "Custom/VariantTest" { 속성{ _Color("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _Glossiness("부드러움", 범위(0,1)) = 0.5 _Metallic("금속성", 범위(0,1)) = 0.0
[KeywordEnum(색상, 빨간색, 탐욕, 파란색)]
_CHANGECOLOR("ChangeColor", float) = 0
[헤더(일반)]
[토글]_USENORMAL("보통을 사용하시겠습니까?", float) = 0
[Normal]_Normal("Normal", 2D) = "범프" {}
}
서브셰이더{
태그{ "RenderType" = "불투명" }
LOD 200CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf Standard fullforwardshadows
#pragma multi_compile _CHANGECOLOR_COLOR _CHANGECOLOR_RED _CHANGECOLOR_GREEN _CHANGECOLOR_BLUE
#pragma multi_compile _USENORMAL_OFF _USENORMAL_ON
#pragma shader_feature _USENORMAL_OFF _USENORMAL_ON
//multi_compile은 큰 단위로 빌드 할 때 사용하지 않는 데이터도 포함하여 빌드함.
//shader_feature은 더 작은 단위로 빌드할 때 사용하지 않는 데이터를 포함하지 않음.
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 2.0
sampler2D _MainTex;
//노멀
#if _USENORMAL_ON
sampler2D _Normal;
#endif
struct Input {
float2 uv_MainTex;
//노멀
#if _USENORMAL_ON
fixed2 uv_Normal;
#endif
};
half _Glossiness;
half _Metallic;
fixed4 _Color;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
void surf(Input IN, inout SurfaceOutputStandard o) {
fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color;
#if _CHANGECOLOR_COLOR
o.Albedo = _Color;
#elif _CHANGECOLOR_RED
o.Albedo = fixed3(1, 0, 0);
#elif _CHANGECOLOR_GREEN
o.Albedo = fixed3(0, 1, 0);
#elif _CHANGECOLOR_BLUE
o.Albedo = fixed3(0, 0, 1);
#endif
//노멀맵 사용
#if _USENORMAL_ON o.Normal = UnpackNormal(tex2D(_Normal, IN.uv_Normal)); #endif o.Metallic = _Metallic; o.Smoothness = _Glossiness; o.Alpha = c.a; } ENDCG } FallBack "Diffuse" } 버텍스 로컬좌표 이동 (Vertex Move Local Position)
// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,)' with 'UnityObjectToClipPos()'
Shader "Custom/LocalPosition" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Albedo (RGB)", 2D) = "white" {} _Glossiness ("Smoothness", Range(0,1)) = 0.5 _Metallic ("Metallic", Range(0,1)) = 0.0_Amount("금액", 범위(0, 1)) = 0 //_Amount2("금액2", 범위(0, 1)) = 0 _VectorTest("벡터테스트", 벡터) = (0, 0, 0, 0) _NoiseTex("NoiseTex", 2D) = "흰색" {} } 서브셰이더 { 태그 { "RenderType"="불투명"} LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 표준 꼭지점:vert
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
샘플러2D _MainTex;
Sampler2D _GrabTexture;
Sampler2D _NoiseTex;
구조체 입력 {
float2 uv_MainTex;
};
반_광택;
하프 _메탈릭;
고정4 _색상;
정액;
//고정_Amount2;
고정4 _VectorTest;
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
무효 vert(appdata_full v 내부) {
고정3 Disp = tex2Dlod(_NoiseTex,fixed4(v.texcoord.xy * 2, 0, 0));
고정4 CamPosition = mul(unity_WorldToObject, _VectorTest.xyz);
v.vertex = lerp(v.vertex, CamPosition, saturate((Disp.r < _Amount)));
}
void Surf (입력 IN, inout SurfaceOutputStandard o) {
// 알베도는 색상별로 착색된 텍스처에서 나옵니다.
//고정3 TestUV = IN.worldPos - mul(unity_ObjectToWorld, float4(0, 0, 0, 1)).xyz;
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.알베도 = c;
o.방출 = 0;
o.메탈릭 = _메탈릭;
o.부드러움 = _광택;
o.알파 = 1;
}
ENDCG
}
대체 ""
}
각 맵에 대한 카메라 데이터 전송
Sampler2D _CameraGBufferTexture1; 고정4 c = tex2D (_CameraGBufferTexture1, screenUV); 로컬 객체 UV
구조체 입력 { 고정3 월드포스; };
고정3 TestUV = IN.worldPos - mul(unity_ObjectToWorld, float4(0, 0, 0, 1)).xyz;
원거리 조정 버텍스무효 vert(appdata_full v 내부) { float4 worldPosition = mul(unity_ObjectToWorld, v.vertex); // 정점의 월드 공간 위치를 얻습니다. half2 wpToCam = _WorldSpaceCameraPos.xz - worldPosition.xz; // 벡터를 카메라로 가져오고 수직 구성 요소를 닫습니다. 절반 거리 = dot(wpToCam, wpToCam); // 정점에서 카메라까지의 거리를 제곱한 것입니다. 이 거듭제곱은 곡률을 제공합니다. worldPosition.y -= 거리 * 0.01; // 거리의 계수와 제곱으로 수직 위치를 오프셋합니다. // 기본값 0.01은 1m 거리에서 1cm, 10m에서 1m, 100m에서 100m만큼 위치를 낮춥니다. 고정4 CamPosition = mul(unity_WorldToObject, worldPosition); v.vertex = lerp(v.vertex, CamPosition, _Amount); // 위치를 객체 공간으로 재투영 }
클립아트 백업(커맨드 백업) C# 펼쳐보기를 만든 뒤 새로운 내용을 만들어 보세요. 가장하단의 _GrabBlurTexture를 Sampler2D 데이터로 가져오면 됩니다.
UnityEngine 사용; UnityEngine.Rendering 사용; System.Collections.Generic을 사용합니다.
// 개요는 _ReadMe.txt를 참조하세요. [편집 모드에서 실행] 공개 클래스 CommandBufferBlurRefraction: MonoBehaviour { 공개 셰이더 m_BlurShader; 프라이빗 머티리얼 m_Material;
개인용 카메라 m_Cam;
// 우리를 렌더링하는 카메라에 명령 버퍼를 추가하고 싶을 것입니다.
// 그래서 사전을 가지고 있습니다.
private Dictionary<Camera,CommandBuffer> m_Cameras = new Dictionary<Camera,CommandBuffer>();
// 추가한 모든 카메라에서 명령 버퍼를 제거합니다.
개인 무효 정리()
{
foreach(m_Cameras의 var 캠)
{
if (캠.키)
{
cam.Key.RemoveCommandBuffer(CameraEvent.AfterSkybox, cam.Value);
}
}
m_Cameras.Clear();
Object.DestroyImmediate(m_Material);
}
공개 무효 OnEnable()
{
정리();
}
공개 무효 OnDisable()
{
정리();
}
// 카메라가 우리를 렌더링할 때마다 명령 버퍼를 추가하여 작업을 수행합니다.
공공 무효 OnWillRenderObject()
{
var act = gameObject.activeInHierarchy && 활성화;
만약 (!act)
{
정리();
반품;
}
var cam = Camera.current;
만약 (!캠)
반환;CommandBuffer buf = null;
// 이 카메라에 명령 버퍼를 이미 추가했습니까? 그러면 할 일이 없습니다.
if (m_Cameras.ContainsKey(cam))
반환;
if (!m_Material)
{
m_Material = 새 재질(m_BlurShader);
m_Material.hideFlags = HideFlags.HideAndDontSave;
}
buf = 새로운 CommandBuffer();
buf.name = "화면을 잡고 흐리게 처리";
m_Cameras[cam] = buf;
// 화면을 임시 RT에 복사합니다.
//Trampority RT를 복사합니다.
int screenCopyID = Shader.PropertyToID("_ScreenCopyTexture");
buf.GetTemporaryRT(screenCopyID, -1, -1, 0, FilterMode.Bilinear);
buf.Blit(BuiltinRenderTextureType.CurrentActive, screenCopyID);
// 두 개의 더 작은 RT를 얻습니다.
//int 흐리게ID = Shader.PropertyToID("_Temp1");
//int 흐리게ID2 = Shader.PropertyToID("_Temp2");
//buf.GetTemporaryRT(blurredID, -2, -2, 0, FilterMode.Bilinear);
//buf.GetTemporaryRT(blurredID2, -2, -2, 0, FilterMode.Bilinear);
// 화면 복사를 더 작은 RT로 다운샘플링하고 화면 RT를 해제합니다.
//buf.Blit(screenCopyID, 흐리게ID);
//buf.ReleaseTemporaryRT(screenCopyID);
//// 수평 흐림
//buf.SetGlobalVector("오프셋", new Vector4(4.0f/Screen.width,0,0,0));
//buf.Blit(blurredID, 흐리게ID2, m_Material);
//// 수직 흐림
//buf.SetGlobalVector("오프셋", new Vector4(0,4.0f/Screen.height,0,0));
//buf.Blit(blurredID2, 흐리게ID, m_Material);
//// 수평 흐림
//buf.SetGlobalVector("오프셋", new Vector4(8.0f/Screen.width,0,0,0));
//buf.Blit(blurredID, 흐리게ID2, m_Material);
//// 수직 흐림
//buf.SetGlobalVector("오프셋", new Vector4(0,8.0f/Screen.height,0,0));
//buf.Blit(blurredID2, 흐리게ID, m_Material);
//렌더링을 정의한다.
buf.SetGlobalTexture("_GrabBlurTexture", screenCopyID);
cam.AddCommandBuffer(CameraEvent.AfterSkybox, buf);
}
}
GGX스펙큘러
고정3 H = IN.viewDir; 고정된 NdotV = 포화(dot(o.Normal, H)); //내적 float NdotV_2 = NdotV * NdotV; float a_2 = _a * _a; float FinalRender = a_2 / pow(NdotV_2 * (a_2 - 1.0) + 1.0, 2.0);
이더 블렌딩, 컬링 뎁스, 테스트 스텐실 프로퍼티스 정리 (서페이스이더스텐실대기 Render Queue에서는 2501이상에서만 작동합니다.)
속성 {[헤더(블렌드 상태)]
[Enum(UnityEngine.Rendering.BlendMode)] _SrcBlend("SrcBlend", Float) = 1 //"1"
[Enum(UnityEngine.Rendering.BlendMode)] _DstBlend("DestBlend", Float) = 0 //"0"
[헤더(CullDepthTest)]
[Enum(UnityEngine.Rendering.CullMode)] _Cull("Cull", Float) = 2 //"뒤로"
[Enum(UnityEngine.Rendering.CompareFunction)] _ZTest("ZTest", Float) = 4 //"LessEqual"
[Enum(Off,0,On,1)] _ZWrite("ZWrite", Float) = 1.0 //"켜기"
[Enum(UnityEngine.Rendering.ColorWriteMask)] _ColorWriteMask("ColorWriteMask", Float) = 15 //"모두"
[헤더(스텐실)]
[스텐실]
_Ref("Ref", Float) = 0 //"모두"
[Enum(UnityEngine.Rendering.CompareFunction)] _Comp("Comp", Float) = 0 //"뒤로"
[Enum(UnityEngine.Rendering.StencilOp)] _Pass("Pass", Float) = 0 //"뒤로"
}
Blend[_SrcBlend][_DstBlend] //현재소스 X _SrcBlend + 배경소스 X _DstBlend
선별[_추출]
Z테스트[_Z테스트]
Z쓰기[_ZWrite]
컬러마스크[_ColorWriteMask]
스텐실{
참조[_Ref]
Comp [_Comp]
패스 [_패스]
}
통과{}
Unity 기본Ui에서 스크롤 FadeOut 처리이더
셰이더 "Mobile/ScrollViewFadeMask" { 속성 { _Color ("색상", 색상) = (0.5,0.5,0.5,0.5) [HideInInspector]_MainTex ("알베도(RGB)", 2D) = "흰색" {} _Stencil("스텐실 ID", Float) = 0 _Alpha("전체알파", Range(0, 1)) = 1 _MaxLeft(" 반대 페이드", Range(-1, 0)) = 0 _MaxRight("오른쪽 페이드", Range(-1, 0)) = 0 _MaxUp("위쪽으로 Fade", Range(-1, 0)) = 0 _MaxDown("아래쪽 페이드", Range(-1, 0)) = 0 _HorizontalLineMul("가로 경계선 강도", int) = 20 _VerticalLineMul("세로 경계선 강도", int) = 20 } 서브셰이더 { 태그
LOD 200
조명 끄기
Z쓰기 끄기
Z테스트 끄기
SrcAlpha OneMinusSrcAlpha 블렌드
스텐실{
참조 1
비교 동등
패스 유지
}
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 NoLighting 알파:페이드
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 2.0
샘플러2D _MainTex;구조체 입력 {
float2 uv_MainTex;
고정4 스크린Pos;
};
고정4 _색상;
고정 _Alpha;
고정 _MaxLeft; // 분리 마스크
고정 _MaxRight; //맞다 마스크
고정 _MaxUp; //위 쪽 마스크
고정 _MaxDown; //밑쪽 마스크
고정 _HorizontalLineMul; //가로 매듭
고정 _VerticalLineMul; //세로 강도
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_CBUFFER_START(속성)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_CBUFFER_END
void Surf (입력 IN, 입력 SurfaceOutput o) {
고정3 ScreenUV = IN.screenPos.xyz / IN.screenPos.a; //화면으로
고정 LeftMask = saturate((ScreenUV.x + _MaxLeft) * _HorizontalLineMul); // 분리마스크
고정 RightMask = saturate((1 - ScreenUV.x + _MaxRight) * _HorizontalLineMul); //맞다 마스크
고정 UpMask = saturate((1 - ScreenUV.y + _MaxUp) * _VerticalLineMul); //위 쪽 마스크
고정 DownMask = saturate((ScreenUV.y + _MaxDown) * _VerticalLineMul); //아래쪽 마스크
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.알베도 = c.rgb;
o.Alpha = c.a * _Alpha * LeftMask * RightMask * DownMask * UpMask;
}
고정4 조명NoLighting(SurfaceOutput s, 고정3 lightDir, 고정 atten)
{
고정4c;
c.rgb = s.알베도;
c.a = s.알파;
c를 반환;
}
ENDCG
}
대체 "확산"
}
모바일에서 사용시 주의사항
mul(UNITY_MATRIX_MVP, *) <== 이러한 형태의 "행렬 * 벡터 출발"에서 벡터 크기와 길이가 일치하지 않도록, PC 모듈에 변형하여 적용
Android, iOS 같은 모바일 제품이 등장합니다. (쉐이더를 사용하는 것으로 응답됨)
mul( (float3x3)UNITY_MATRIX_MVP, vector3 ) <== 이렇게 압축된 벡터 크기를 오히려 반대해야 했습니다.
언릿이더 메이크
#pragma 표면 서핑 NoLighting
- 고정4 LightingNoLighting(SurfaceOutput s, 고정3 lightDir, 고정 atten) {
- 고정4c;
- c.rgb = s.알베도;
- c.a = s.알파;
- c를 반환; }
-
엠비언트 라이트 데이터를 직접 공유한다 https://docs.unity3d.com/kr/current/Manual/SL-UnityShaderVariables.html
UNITY_LIGHTMODEL_AMBIENT
방사형 흐림셰이더 "ImageEffect/Shader_ImageBlender" { 속성 { [HDR]_색상("색상", 색상) = (1,1,1,1) _MainTex ("Image(메인 이미지)", 2D) = "white" {} _BlurAmount("_BlurAmount", 범위(0, 10)) = 1 _MaskAmount("_MaskAmount", 범위(0, 10)) = 1 } 서브셰이더 { 태그 { "RenderType"="투명" "큐" = "투명"} LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 Lambert alpha:fade noshadow noambient novertexlights nolightmap nodynlightmap nodirlightmap nofog nometa noforwardadd nolppv noshadowmask halfasview interpolateview
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 2.0
샘플러2D _MainTex;
구조체 입력 {
고정2 uv_MainTex;
};
고정4 _색상;
고정 _MaskAmount;
고정 _BlurAmount;
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
void Surf (입력 IN, 입력 SurfaceOutput o) {
고정4 c = tex2D (_MainTex, IN.uv_MainTex);
고정2 UVMinus = IN.uv_MainTex - 0.5;
고정 플레어 = 길이(UVMinus);
UVMinus /= 플레어;
고정3 방사형 = c;
float Addfloat[11] = { -0.08,-0.05,-0.03,-0.02,-0.01,0,0.01,0.02,0.03,0.05,0.08 };
for (int i = 0; i < 10; ++i)
{
Radial += tex2D(_MainTex, IN.uv_MainTex + (UVMinus * Addfloat[i] * _BlurAmount));
}
방사형 /= 11;
고정 마스크 = 포화(Flare * _MaskAmount);
o.Emission = lerp(c, 방사형, 마스크);
o.Alpha = _Color.a;
}
ENDCG
}
FallBack "레거시 셰이더/투명/VertexLit"
}
파티클 커스텀 시스템 데이터 Vertex Stream셰이더 "입자/CustomData" { 속성{ _Color("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _Glossiness("부드러움", 범위(0,1)) = 0.5 _Metallic("금속성", 범위(0,1)) = 0.0 } 서브셰이더{ 태그{ "Queue" = "투명" "RenderType" = "투명" } SrcAlpha OneMinusSrcAlpha 블렌드 Z쓰기 끄기 LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 표준 정점:vert 알파
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
//사용할 데이터
샘플러2D _MainTex;
반_광택;
하프 _메탈릭;
고정4 _색상;
//#1 -> #2
구조체 appdata_particles {
//기본적으로 존재해야 할 존재
float4 정점 : 위치;
float3 일반 : 일반;
float4 색상 : 색상;
float4 texcoord : TEXCOORD0;
//맞춤형 데이터
float4 CustomDataTest : TEXCOORD1;
float4 CustomDataTest2 : TEXCOORD2;
};
//#3 -> #4
struct Input { //Surface데이터로 확실히줌
float2 uv_MainTex; //기본 UV 표현을 인용해1 (필수)
float2 texcoord; //기본 UV 표현을 예시2 (필수)
float4 CustomDataFinal; //첫번째 커스텀 데이터
float4 CustomDataFinal2; //두번째 커스텀 데이터
float4 색상;
};
///////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////
//#2 -> #3
//구조적 입력으로 줌.
void vert(inout appdata_particles v, out 입력 o) {
o.uv_MainTex = v.texcoord.xy; //기본 UV 표현을 인용해1 (필수)
o.texcoord = v.texcoord.zw; //기본 UV 표현을 예시2 (필수)
o.color = v.color;
o.CustomDataFinal = v.CustomDataTest;
o.CustomDataFinal2 = v.CustomDataTest2;
}
//#4 최종
void Surf(입력 IN, inout SurfaceOutputStandard o) {
고정3 BaseColor = tex2D(_MainTex, IN.uv_MainTex) * _Color;
고정 Alpha = IN.CustomDataFinal.a * IN.CustomDataFinal2.a;
o.Albedo = BaseColor * (IN.CustomDataFinal.rgb + IN.CustomDataFinal2.rgb);
o.메탈릭 = _메탈릭;
o.부드러움 = _광택;
o.알파 = 알파;
}
ENDCG
}
대체 "확산"
}유니티 프로젝터를 지원하는 쉐이더 (유니티 에셋 스토어에 있는 ‘Standard assets’에서 Projector 폴더를 다운 받아야 함.)
// Upgrade NOTE: replaced '_Projector' with 'unity_Projector'
// Upgrade NOTE: replaced '_Projector' with 'unity_Projector'
Shader "Custom/ProjectorShader" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Albedo (RGB)", 2D) = "white" {} } SubShader { Tags { "Queue" = "Transparent"} LOD 200
Blend SrcAlpha One
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf Lambert vertex:vert noshadow noambient novertexlights nolightmap nodynlightmap nodirlightmap nofog nometa noforwardadd nolppv noshadowmask
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 2.0
float4x4 unity_Projector; //유니티 프로젝트 매트릭스
struct Input {
float2 uv_MainTex;
float4 posProj : TEXCOORD0; // 프로젝트 공간 좌표
};
void vert(inout appdata_full v, out Input o) {
UNITY_INITIALIZE_OUTPUT(Input, o);
o.posProj = mul(unity_Projector, v.vertex);
}
sampler2D _MainTex;
fixed4 _Color;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
void surf (Input IN, inout SurfaceOutput o) {
// Albedo comes from a texture tinted by color
//fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
fixed4 ProRender = tex2Dproj(_MainTex, UNITY_PROJ_COORD(IN.posProj)) * _Color;
o.Albedo = ProRender;
}
ENDCG
}
FallBack ""
}
외부에서 제어 가능한 쉐이더 데이터 만들기 https://docs.unity3d.com/ScriptReference/Shader.SetGlobalVector.html
-
쉐이더 안에 들어가는 데이터의 앞에 uniform이라는 명령어를 붙인다. (Properties 값을 주석 처리 해야 함.) uniform fixed4 Global_Position;
-
다른 코드에서 SetGlobalVector로 접근한다.
public class Pointer : MonoBehaviour {
public GameObject PointerObject;
// Use this for initialization
void Start () {
}// 업데이트는 프레임당 한 번씩 호출됩니다.
무효 업데이트 () {
Vector4 pos = PointerObject.transform.position;
Shader.SetGlobalVector("Global_Position", pos);
}
}
월드를 이더에 대입하기
셰이더 "Custom/SpghericalMask" { 속성 { _Color ("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _광택("부드러움", 범위(0,1)) = 0.5 _Metallic ("금속성", 범위(0,1)) = 0.0 _Position("_Position", 벡터) = (0, 0, 0, 0) _Radius("_Radius", 범위(0, 100)) = 0 _부드러움("_부드러움", 범위(0, 100)) = 0 } 서브셰이더 { 태그 { "RenderType"="불투명" } LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 표준 fullforwardshadows
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
샘플러2D _MainTex;
구조체 입력 {
float2 uv_MainTex;
고정3 월드포스;
};
반_광택;
하프 _메탈릭;
고정4 _색상;
고정4_위치;
고정_반경;
고정_부드러움;
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
void Surf (입력 IN, inout SurfaceOutputStandard o) {
//기본 색상
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
//흑백 처리
고정3 GrayScale = (c.r + c.g + c.b) * 0.333;
//위치 처리기
고정 p2w = 거리(_Position, IN.worldPos); //_Position의 탐구와 월드좌표의 거리를 알아냄.
고정 p2wMask = 포화((p2w - _Radius) / - _Softness); //거리를 정당하게 일러스트 처리 처리
고정4 LerpColor = lerp(GrayScale.r, c, p2wMask);o.Albedo = LerpColor.rgb;
// 금속성과 부드러움은 슬라이더 변수에서 나옵니다.
o.메탈릭 = _메탈릭;
o.부드러움 = _광택;
o.알파 = c.a;
}
ENDCG
}
대체 "확산"
}
Vertex:vert를 상대로 데이터로 하기
셰이더 "사용자 정의/테스트" { 속성 { [HDR]_색상("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {}
_MetallicSmoothness("_MetallicSmoothness", 2D) = "검은색" {}
[Normal]_Normal("_Normal", 2D) = "흰색" {}
_HeightMap("_HeightMap", 2D) = "흰색" {}
_MaskRange("_MaskRange", 범위(0, 1)) = 0
_Amount("_Amount", 범위(0, 1)) = 0
_NoiseTexture("_NoiseTexture", 2D) = "검은색" {}
}
서브셰이더{
태그 { "RenderType" = "불투명" }
LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 표준 fullforwardshadows 정점:vert
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
//VertData
고정_금액;
샘플러2D _MainTex;
Sampler2D _Normal;
Sampler2D _MetallicSmoothness;
Sampler2D _HeightMap;
Sampler2D _NoiseTexture;
고정4 _색상;
고정 _MaskRange;
무효 vert(appdata_full v 내부) {
float3 disp = tex2Dlod(_NoiseTexture,fixed4(v.texcoord.xy, 0, 0));
v.vertex.xyz += v.normal * disp.r * _Amount;
//해당 값을 더하거나, 단순화하면 됩니다. (v.Normal에 삽입하는 라면 곱하기, 개별적인 거문고로 구성요소면 Add)
}
구조체 입력 {
float2 uv_MainTex;
};
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
void Surf (입력 IN, inout SurfaceOutputStandard o) {고정4 c = tex2D (_MainTex, IN.uv_MainTex);
고정 MatellicFinal = tex2D(_MetallicSmoothness, IN.uv_MainTex);
고정4 SmoothnessFinal = tex2D(_MetallicSmoothness, IN.uv_MainTex);
고정3 NormalFinal = UnpackNormal(tex2D(_Normal, IN.uv_MainTex));
SandMask = tex2D(_HeightMap, IN.uv_MainTex)를 수정했습니다.
if (샌드마스크 <= _MaskRange)
{
샌드마스크 = 1;
}
그렇지 않으면
{
샌드마스크 = 0;
}
o.Albedo = lerp(c.rgb, _Color, SandMask);
// 금속성과 부드러움은 슬라이더 변수에서 나옵니다.
o.Metallic = MatellicFinal.r;
o.부드러움 = SmoothnessFinal.a;
o.Normal = NormalFinal;
//o.Alpha = c.a;
}
ENDCG
}
대체 "확산"
}
Vertex:vert로 변형된 버텍스까지 그림자 처리 하기
#pragma 표면 서핑 표준 addshadow
atan2 부담식을 X축으로 돌려보내
고정4 c = tex2D (_MainTex,fixed2(atan2((IN.uv_MainTex.x - 0.5) * 0.5, (IN.uv_MainTex.y - 0.5) * 0.5), 0)) ;
*길이를 추가로 계산하는 것은 전혀 없는지 그리고 원으로 말아줌.
버텍스 색상을 받음
셰이더 "TestTest" { 속성 { _Color ("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _Cutoff("기본 알파 컷오프", 범위(0, 1)) = 0.5 _광택("부드러움", 범위(0,1)) = 0.5 _Metallic ("금속성", 범위(0,1)) = 0.0 [Normal]_Normal("_Normal", 2D) = "범프" {} } 서브셰이더 { 태그
LOD 200
컬오프
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 표준 알파벳:_Cutoff
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
샘플러2D _MainTex;
Sampler2D _Normal;
구조체 입력 {
float2 uv_MainTex;
고정3 정점색상 : 색상;
};
반_광택;
하프 _메탈릭;
고정4 _색상;void Surf (입력 IN, inout SurfaceOutputStandard o) {
// 알베도는 색상별로 착색된 텍스처에서 나옵니다.
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
고정3 NormalFinal = UnpackNormal(tex2D(_Normal, IN.uv_MainTex));
o.Albedo = c.rgb * IN.vertexcolor;
// 금속성과 부드러움은 슬라이더 변수에서 나옵니다.
o.메탈릭 = _메탈릭;
o.부드러움 = _광택;
o.Normal = NormalFinal;
o.알파 = c.a;
}
ENDCG
}
FallBack "레거시 셰이더/투명/컷아웃/VertexLit"
}
회전이더
// 업그레이드 참고: 'mul(UNITY_MATRIX_MVP,)'를 'UnityObjectToClipPos()'로 교체했습니다.
셰이더 "Jinho/EarthSpellAlpha" { 속성 { [HDR]_색상("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _ViewAmount ("_ViewAmount", 범위(0, 0.2)) = 0.2
_RotationSpeed("_RotationSpeed (텍스처 속도 회전)", Range(0, 10)) = 1
}
서브셰이더 {
태그 { "RenderType"="투명" "큐" = "투명"}
LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 램버트 알파:페이드 정점:vert
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 2.0
샘플러2D _MainTex;
//sampler2D _AlphaCircle; //알맵파
구조체 입력 {
고정2 uv_MainTex;
//고정2 uv_AlphaCircle; //알맵파UV
};
고정4 _색상;
고정_ViewAmount; //보이는 정도
float_RotationSpeed; //텍스처 회전 속도
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)void vert(inout appdata_base v) {
//fivot
float2 pivot = float2(0.5, 0.5); //텍스처 전체의 피봇을 0.5만큼 더함.
//Angle
float sinAngle = sin(_RotationSpeed);
float cosAngle = cos(_RotationSpeed);
float2x2 rotationMatrix = float2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
v.texcoord.xy = mul(rotationMatrix, v.texcoord.xy - pivot) + pivot; //회전 후 피봇 만큼 UV를 이동
}
////https://forum.unity.com/threads/rotation-of-texture-uvs-directly-from-a-shader.150482/
////참고자료
void surf (Input IN, inout SurfaceOutput o) {
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
fixed4 ViewFinal = (1 - (((IN.uv_MainTex.x - 0.5) * (IN.uv_MainTex.x - 0.5)) + ((IN.uv_MainTex.y - 0.5) * (IN.uv_MainTex.y - 0.5)))) + _ViewAmount; //보여지는 량.
//fixed _ViewAmount = frac(-_Time.y * _ViewSpeed); //이미지 나타나는 속도
if (ViewFinal.r >= 1)
{
ViewFinal = 1;
}
else
{
ViewFinal = 0;
}
o.Emission = c * ViewFinal;
o.Alpha = c.a * ViewFinal;
}
ENDCG
}
FallBack "Legercy Shaders/Transparent/VertexLit"
}
오브젝트 탄젠트에 대한 월드 노멀 가져오기. (worldPos 와의 차이점 : worldPos는 좌표 내의 0~무한대의 수치를 출력함. WorldNormalVector는 현재 오브젝트와 월드 상에서의 노멀 방향에 대한 float값만을 출력함.) struct Input { float2 uv_MainTex; float2 uv_BumpMap; float3 worldNormal; INTERNAL_DATA }; void surf (Input IN, inout SurfaceOutput o) { o.Albedo = tex2D (_MainTex, IN.uv_MainTex).rgb * 0.5; o.Normal = UnpackNormal (tex2D (_BumpMap, IN.uv_BumpMap)); float3 worldNormal = WorldNormalVector (IN, o.Normal); }
World Uv Texturing
Shader "Jinho/Evi_SnowShader" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Color(RGB)", 2D) = "white" {} _Smoothness ("Smoothness", Range(0,1)) = 0.5 _Metallic ("Metallic", Range(0,1)) = 0.0[헤더(SnowSetting)] [NoScaleOffset]_SnowColor("_SnowColor", 2D) = "검은색" {} _UVTiling("_UVTiling", 범위(0, 0.1)) = 0.1 [NoScaleOffset]_ViewNoise("_ViewNoise", 2D) = "검은색" {} _cut("_cut", 범위(0, 1)) = 0 } 서브셰이더 { 태그 { "RenderType"="불투명" } LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 표준
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 2.0
샘플러2D _MainTex;
Sampler2D _SnowColor;
Sampler2D _ViewNoise;
구조체 입력 {
고정2 uv_MainTex;
고정3 월드포스;
고정3 월드보통;
};
고정_부드러움;
고정_메탈릭;
고정4 _색상;
고정 _UVTiling;
고정_컷; //눈에 보이는 정도
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
void Surf (입력 IN, inout SurfaceOutputStandard o) {
//기본적으로 처리
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
//스노우텍스
//텍스처 처리용 월드 UV
고정2 UVtop = 고정2(IN.worldPos.x, IN.worldPos.z) * _UVTiling;
고정2 UVfront = 고정2(IN.worldPos.x, IN.worldPos.y) * _UVTiling;
고정2 UVside = 고정2(IN.worldPos.y, IN.worldPos.z) * _UVTiling;
//방향에 따른 결과 출력
고정4 TexTop = tex2D(_SnowColor, UVtop); //윗면으로
고정4 Texfront = tex2D(_SnowColor, UVfront); //정면으로
고정4 Texside = tex2D(_SnowColor, UVside); //옆으로 가면
//텍스처 출력 마스크
고정 MaskTop = abs(IN.worldNormal.y); //상단 마스크
고정 MaskSide = abs(IN.worldNormal.x); //옆면마스크//눈 효과 최종 렌더링
fixed3 SnowFinal = lerp(Texfront, TexTop, abs(MaskTop));
fixed3 SnowFinal2 = lerp(SnowFinal, Texside, abs(MaskSide));
//스노우 마스크용 처리
//방향에 따른 텍스쳐 출력
fixed4 TexTop_SnowMask = tex2D(_ViewNoise, UVtop); //윗면 렌더링
fixed4 Texfront_SnowMask = tex2D(_ViewNoise, UVfront); //정면 렌더링
fixed4 Texside_SnowMask = tex2D(_ViewNoise, UVside); //옆면 렌더링
fixed3 SnowMask = lerp(Texfront_SnowMask, TexTop_SnowMask, abs(MaskTop));
fixed3 SnowMask2 = lerp(SnowMask, Texside_SnowMask, abs(MaskSide));
if (SnowMask2.r >= _cut)
SnowMask2.r = 0;
else
SnowMask2.r = 1;
//최종 렌더링
o.Albedo = lerp(c.rgb, SnowFinal2, SnowMask2.r);
o.Metallic = _Metallic;
o.Smoothness = _Smoothness;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}
Water Shader
Shader "Jinho/Water_1" { Properties { [NoScaleOffset]_CubeMap("_CubeMap", Cube) = ""{} _Normal("_Normal", 2D) = "bump" {}
[Header(RimLight)]
_RimMul("_RimMul", Range(0, 10)) = 5
_RimPow("_RimPow", Range(0, 50)) = 10
[Header(Specular)]
_SPPow("_SPPow", Range(0, 1000)) = 80
_SPMul("_SPMul", Range(0, 100)) = 20
[Header(VertexMove)]
_WaveH ("_WaveH", Range(0, 0.5)) = 0.1
_WaveL ("_WaveL", Range(0, 30)) = 12
_WaveTime ("_WaveTime", Range(0, 10)) = 1
[Header(GrabTexture)]
_GrabMul ("_GrabMul", Range(0.1, 5)) = 2
_GrabPow("_GrabPow", Range(0.1, 5)) = 3.5
[Header(MeshAttach)]
_InvFade("_InvFade", Range(0, 1)) = 0.15
_MeshAttachPower("_MeshAttachPower", Range(0, 1)) = 0.5
_MeshAttachGradation("_MeshAttachGradation", 2D) = "white" {}
}
SubShader{
Tags { "RenderType" = "Trasparent" "Queue" = "Transparent" }
GrabPass{}
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf WaterSpecular alpha:fade vertex:vert
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 4.0//sampler2D _MainTex;
sampler2D _Normal;
samplerCUBE _CubeMap; //큐브맵
sampler2D _GrabTexture;
//접촉면 출력
sampler2D _CameraDepthTexture; //카메라 뎁스값
fixed _InvFade; // 최종값에 곱하는 량
sampler2D _MeshAttachGradation; //접촉면 색 그라데이션
struct Input {
//fixed2 uv_MainTex;
fixed2 uv_Normal;
fixed3 worldRefl;
INTERNAL_DATA
fixed3 viewDir; //카메라 각도
fixed4 screenPos; //카메라 UV좌표
fixed3 lightColor0; //라이트 컬러
//닿은 표면적 인식
fixed4 projPos; //4개의 값을 받아와야 함.
fixed4 vertex;
fixed2 uv_MeshAttachGradation;
};
fixed _RimMul;
fixed _RimPow;
fixed _SPPow;
fixed _SPMul;
fixed _WaveH;
fixed _WaveL;
fixed _WaveTime;
fixed _GrabMul;
fixed _GrabPow;
fixed _MeshAttachPower;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
void vert(inout appdata_full v, out Input o) {
fixed VertexWave;
VertexWㄹave = sin(abs(v.texcoord.x * 2 - 1) * _WaveL + _Time.y * _WaveTime) * _WaveH;
VertexWave += sin(abs(v.texcoord.y * 2 - 1) * _WaveL + _Time.y * _WaveTime) * _WaveH;
v.vertex.y += VertexWave * 0.5;
//오브젝트 접촉면 출력을 위한 부분
UNITY_INITIALIZE_OUTPUT(Input, o);
o.vertex = UnityObjectToClipPos(v.vertex);
o.projPos = ComputeScreenPos(o.vertex);
COMPUTE_EYEDEPTH(o.projPos.z);
}
void surf (Input IN, inout SurfaceOutput o) {
//기본컬러
//fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;//노멀 처리
fixed3 Normal_1 = UnpackNormal(tex2D(_Normal, fixed2(IN.uv_Normal.x + _Time.x, IN.uv_Normal.y)));
fixed3 Normal_2 = UnpackNormal(tex2D(_Normal, fixed2(IN.uv_Normal.x * 1.35 - _Time.x, IN.uv_Normal.y * 1.35 + _Time.x)));
fixed3 NormalFinal = (Normal_1 + Normal_2) * 0.5;
o.Normal = NormalFinal;
//반사광처리
fixed3 RefColor = texCUBE(_CubeMap, WorldReflectionVector(IN,o.Normal));
//림라이트
fixed3 LdotV = saturate(dot(o.Normal, IN.viewDir));
fixed3 Lim = pow((1 - LdotV) * _RimMul, _RimPow);
//오브젝트 접촉부분 출력
fixed sceneZ = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(IN.projPos))); //카메라 뎁스
fixed partZ = IN.projPos.z; //오브젝트 뎁스
fixed MeshAttach = saturate(_InvFade * (sceneZ - partZ));//카메라 뎁스과 오브젝트 뎁스를 뺀 후 곱하고 잘라냄.
fixed3 MeshAttachFinal = ((1 - MeshAttach));
fixed3 MeshAttachFinal_2 = _MeshAttachPower * _LightColor0.rgb * (MeshAttachFinal * (tex2D(_MeshAttachGradation, fixed2(MeshAttachFinal.r, IN.uv_MeshAttachGradation.y))));
//그랩패스 출력
fixed3 screenUV = IN.screenPos.rgb / IN.screenPos.a;
fixed3 GrabFinal = pow(tex2D(_GrabTexture, screenUV.xy + o.Normal * 0.05 + 0.03) * _GrabMul, _GrabPow);
o.Emission = RefColor * GrabFinal * Lim + MeshAttachFinal_2;
o.Alpha = 1;
}
fixed4 LightingWaterSpecular(SurfaceOutput s, fixed3 lightDir, fixed3 viewDir, fixed atten) {
//스펙큘러
fixed3 H = normalize(lightDir + viewDir);
fixed Spec = saturate(dot(H, s.Normal));
Spec = pow(Spec, _SPPow);
//최종렌더
fixed4 finalColor;
//finalColor.rgb = (Spec * _SPColor.rgb) * _SPMul;
finalColor.rgb = (Spec * _LightColor0.rgb) * _SPMul;
finalColor.a = s.Alpha;
return finalColor;
}
ENDCG
}
FallBack "Legacy Shaders/Trasparent/VertexLit"
}
Circle Texture 만드는 계산식
pow((1 - (((IN.uv_MainTex.x - 0.5) * (IN.uv_MainTex.x - 0.5)) + ((IN.uv_MainTex.y - 0.5) * (IN.uv_MainTex.y - 0.5)))), 50);
또는
float2 dir = texCo - 0.5 ; //원래 텍스처에서 0.5를 뺀다.
float dist = length(dir);밝은 색상의 가치를 가져오세요
셰이더 "Jinho/UnLightDirShader" { 속성 { _Color ("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} } 서브셰이더 { 태그
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 Lambert noshadow noambient novertexlights nolightmap nodynlightmap nodirlightmap nofog nometa noforwardadd nolppv noshadowmask halfasview
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 2.0
샘플러2D _MainTex;
구조체 입력 {
float2 uv_MainTex;
고정4 _LightColor0; // 가벼운 색값을 받아요.
};
고정4 _색상;
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_BUFFER_START(프롭)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_BUFFER_END(프롭)
void Surf (입력 IN, 입력 SurfaceOutput o) {
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = _LightColor0.rgb; // 라이트 컬러 설정
o.알파 = c.a;
}
ENDCG
}
대체 "확산"
}
처리의 Z값을 계산하는 것이 더.
셰이더 "Jinho/OnltyObjectDepth" { 속성 {
_partZMul("partZMul", int) = 0.04 //꼭 0.04여야 합니다. 상대방이 수신한 메시지입니다.
_partZPower("partZPower", int) = 5 //시각적으로 확실하게 유지됩니다.
}
서브셰이더{
태그 { "RenderType" = "불투명" }
LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 램버트 정점:vert
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 2.0
샘플러2D _MainTex;
구조체 입력 {
고정2 uv_MainTex;
고정4 프로젝트;
};
고정 _partZMul;
고정 _partZPower;// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_CBUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_CBUFFER_END
//유니티 내부에서 오브젝트의 Z값을 가져옴.
void vert(inout appdata_full v, out Input o)
{
UNITY_INITIALIZE_OUTPUT(Input, o);
COMPUTE_EYEDEPTH(o.projPos.z);
}
void surf (Input IN, inout SurfaceOutput o) {
float partZ = IN.projPos.z; //오브젝트 Z값
o.Emission = pow(saturate(partZ * _partZMul), _partZPower);
//시각적으로 확실하게 보여주기 위한 계산
}
ENDCG
}
FallBack "Diffuse"
}
오브젝트의 표면 계산하는 쉐이더
Shader "Custom/SurfaceDepthTexture" { Properties{ [HDR]_Color("Color", Color) = (1,1,1,1) _MainTex("Albedo (RGB)", 2D) = "white" {} _InvFade("Soft Factor", Range(0.01,3.0)) = 1.0 } SubShader{ Tags{ "Queue" = "Transparent" "RenderType" = "Transparent" } LOD 200
cull off
CGPROGRAM
#pragma surface surf Lambert alpha:fade vertex:vert
//vertex:vert라는 void를 정의 한 후 그 안에서 유니티 내부 데이터를 불러옴.
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 4.0
//pragma Target이 4.0 인지 확인할것. (지원이 많이 안되는 쉐이더는 3.0으로도 충분하나 복합적으로 기능이 들어갈 경우 4.0 이상을 설정해야 함.)
struct Input
{
fixed4 vertex; //vertex값 들어와야 함.
fixed4 projPos; //4개의 값을 받아와야 함.
fixed2 uv_MainTex;
};
// 유니티 내부에서 오브젝트의 뎁스 값을 불러옴. void vert(inout appdata_full v, out Input o) { UNITY_INITIALIZE_OUTPUT(Input,o);
o.vertex = UnityObjectToClipPos(v.vertex);
o.projPos = ComputeScreenPos(o.vertex);
COMPUTE_EYEDEPTH(o.projPos.z);
}
sampler2D _MainTex;
sampler2D _CameraDepthTexture; //카메라 뎁스값
fixed _InvFade; // 최종값에 곱하는 량
fixed3 _Color;
fixed fade;
void surf(Input IN, inout SurfaceOutput o)
{
fixed4 d = tex2D(_MainTex, IN.uv_MainTex);
float sceneZ = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(IN.projPos))); //카메라 뎁스float partZ = IN.projPos.z; //오브젝트 뎁스
fade = saturate(_InvFade * (sceneZ - partZ)); //카메라 뎁스과 오브젝트 뎁스를 뺀 후 곱하고 잘라냄.
o.Emission = saturate(1 - float3(fade, fade, fade)) * _Color + d.rgb; //오브젝트 닿는 면적 * 컬러 + 텍스처
o.Alpha = saturate(0.7 + 1 - float3(fade, fade, fade)); //알파값 뺌.
}
ENDCG
}
}
뎁스 텍스쳐 받아오기 (Forward 렌더링에서는 작동안함.)
sampler2D _CameraDepthTexture;
struct Input {
fixed4 screenPos;
};
void surf (Input IN, inout SurfaceOutput o) {
fixed3 screenUV2 = IN.screenPos.rgb / IN.screenPos.a;
fixed4 Depth = tex2D(_CameraDepthTexture, screenUV2);
}
ENDCG
버텍스 쉐이더 vertex:vert
float _Amount;
void vert (inout appdata_full v) {
v.vertex.xyz += v.normal * _Amount;
}
큐브맵 컬러값 받아오기
Cutout 쉐이더 작성
클립 계산식으로 제외하기. clip(c.a - 0.7);
Shader "Custom/Test" { Properties { _Color ("Color", Color) = (1,1,1,1) _MainTex ("Albedo (RGB)", 2D) = "white" {} _Cutoff("Base Alpha cutoff", Range(0, 1)) = 0.5 _Glossiness ("Smoothness", Range(0,1)) = 0.5 _Metallic ("Metallic", Range(0,1)) = 0.0 } SubShader { Tags { "RenderType"="TransparentCutout" "Queue" = "AlphaTest" } LOD 200
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf Standard fullforwardshadows alphatest:_Cutoff 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;
half _Metallic;
fixed4 _Color;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)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.rgb;
// Metallic and smoothness come from slider variables
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Legacy Shaders/Transparent/Cutout/VertexLit"
}
쉐도우 제거 하기 (그림자 제거하기) FallBack "Legercy Shaders/Transparent/VertexLit"
Surface Shader XRay효과
주의사항 : “Queue”는 ALphaTest여야 함.
XRay처리할 쉐이더를 위쪽으로 작성해야 함. 정상 렌더링을 해야할 쉐이더는 아래쪽에 작성 해야 함.
화면 찍어내는 쉐이더. GrabPass
조건 : Tags 렌더링 타입 확인 Subshader 바로 아래에 GrabPass{} 확인 #pragma surface alpha : fade 확인
sampler2D _GrabTexture;
모든 옵션 끄기 noshadow noambient novertexlights nolightmap nodynlightmap nodirlightmap nofog nometa noforwardadd nolppv noshadowmask halfasview interpolateview exclud_path:deferred exclud_path:forward exclud_path:prepass
exclud_path:deferred exclud_path:forward exclud_path:prepass : 작성된 렌더링 패스를 제거합니다. 차례대로 디퍼드 셰이딩, 포워드 패스, 레거시 디퍼드 패스 (제거하고 싶은 패스를 적으면 됨.)
noshadow : 모든 그림자 받기를 비활성화 합니다. (shadow Receiving) noambient : 엠비언트 라이팅 또는 라이트 프로브를 적용하지 않습니다. novertexLights : Forward 렌더링에서 라이트 프로브 또는 버텍스 라이트를 적용하지 않습니다. nolightmap : 실시간 동적 전역 조명 지원을 비활성화 합니다. nodirlightmap : 디렉셔널 라이트맵 지원을 비활성화 합니다. nofog : 유니티 내장 포그 기능을 지원하지 않습니다. nometa : 메타 패스를 만들지 않습니다. (이 패스는 라이트맵 및 동적 전역 조명을 위해 표면 정보를 추출하는 패스입니다.) noforwardadd : 포워드 렌더링 추가 패스를 비활성화 합니다. 그러면 쉐이더는 디렉셔널 라이트 하나만 지원하고, 다른 모든 라이트는 정점당/SH 계산됩니다. 쉐이더도 더 작아집니다.
halfasview - 뷰-방향 대신 하프-디렉션 벡터를 조명 함수에 넘깁니다. 하프-디렉션은 버텍스마다 계산 및 정규화됩니다. 속도가 더 빠르지만 아주 정확하지는 않습니다. (normalize(ViewDir + LightDir)처럼 작동함)
렌더링 타입 태그
- Opaque : 대부분의 쉐이더 (Normal](shader-NormalFamily.html), Self Illuminated, Reflective, Terrain 쉐이더).
- Transparent : 대부분의 알파 블렌딩 쉐이더에서 사용 ((Transparent, 파티클, 글꼴, Terrain 추가 패스 쉐이더).
- TransparentCutout : 알파 테스트 쉐이딩에서 사용. 마스킹 된 투명 쉐이더(Transparent Cutout, 2 패스 식물 쉐이더).
- Background : Skybox 쉐이더.
- Overlay : GUITexture, 후광(Halo), 플레어 쉐이더(Flare shaders).
- TreeOpaque : Terrain 엔진 나무 껍질.
- TreeTransparentCutout : Terrain 엔진 나뭇잎.
- TreeBillboard : Terrain 엔진 빌보드 Tree.
- Grass : terrain 엔진의 grass.
- GrassBillboard : Terrain 엔진 빌보드 Grass. 렌더큐 태그 (ShaderLab: SubShader Tags)
서브 쉐이더는 태그를 사용하여 렌더링 엔진에 렌더링 할 방법과시기를 알려줍니다.
Syntax Tags { "TagName1" = "Value1" "TagName2" = "Value2" } TagName1에 Value1, TagName2에 Value2를 지정합니다. 원하는만큼 태그를 추가 할 수 있습니다.
세부 태그는 기본적으로 키 - 값 쌍입니다. SubShader 태그 안에는 렌더링 순서와 하위 셰이더의 다른 매개 변수를 결정하는 데 사용되는 태그가 있습니다. Unity가 인식하는 다음 태그는 Pass가 아닌 SubShader 섹션 안에 있어야합니다!Unity가 인식하는 내장 태그 이외에, 자신의 태그를 사용하고 Material.GetTag 함수를 사용하여 태그를 쿼리 할 수 있습니다.
렌더링 순서 - 대기열 태그 Queue 태그를 사용하여 객체가 그려지는 순서를 결정할 수 있습니다. Shader는 객체가 속해있는 렌더링 대기열을 결정합니다. 이렇게하면 모든 투명한 셰이더가 모든 불투명 객체 뒤에 그려지는지 확인합니다.
사전 정의 된 렌더링 대기열은 4 개이지만 미리 정의 된 대기열 사이에 더 많은 대기열이있을 수 있습니다. 미리 정의 된 대기열은 다음과 같습니다.
Background -이 렌더링 대기열은 다른 것보다 먼저 렌더링됩니다. 일반적으로 배경에 있어야하는 것들을 위해 이것을 사용합니다.
Geometry (기본값) - 대부분의 객체에 사용됩니다. 불투명 기하학은이 대기열을 사용합니다.
AlphaTest 된 지오메트리는이 대기열을 사용합니다. 기하학 객체와 별도의 대기열입니다. 왜냐하면 모든 단색 객체가 그려진 후에 알파 테스트 객체를 렌더링하는 것이 더 효율적이기 때문입니다.
Transparent -이 렌더링 대기열은 기하학 및 AlphaTest 다음으로 앞뒤 순서로 렌더링됩니다. 알파 블렌딩 된 것 (깊이 버퍼에 쓰지 않는 셰이더)은 여기에 있어야합니다 (glass, particle effects).
Overlay - 이 렌더링 대기열은 오버레이 효과를위한 것입니다. 마지막으로 렌더링 된 것은 모두 여기에 있어야합니다 (예 : 렌즈 플레어). Shader "투명한 대기열 예제" { 하위 쉐이더 { 태그 { "Queue"= "Transparent"} 패스 { // 나머지 셰이더 바디 ... } } } 투명 큐에서 무언가를 렌더링하는 방법을 보여주는 예제
특수한 중간 사용 대기열을 사용할 수 있습니다. 내부적으로 각 큐는 정수 인덱스로 표시됩니다. Background 은 1000, Geometry은 2000, AlphaTest는 2450, Transparent 은 3000, Overlay 는 4000입니다. 셰이더가 다음과 같은 큐를 사용하는 경우 :
태그 { "Queue"= "Geometry + 1"} 이렇게하면 모든 불투명 한 객체 뒤에 객체가 렌더링되지만 투명한 객체 앞에는 렌더링 대기열 인덱스가 2001 (형상 +1)이됩니다. 이 기능은 일부 개체가 다른 개체 집합간에 항상 그려지도록하려는 경우에 유용합니다. 예를 들어, 대부분의 경우 투명한 물은 불투명 한 물체 뒤에 투명한 물체 앞에 그려야합니다.
2500까지의 대기열 ( "기하 +500")은 "불투명"으로 간주되어 최상의 성능을 위해 객체의 그리기 순서를 최적화합니다. 더 높은 렌더링 대기열은 "투명한 오브젝트"로 간주되어 먼 거리에서 렌더링을 시작하고 가장 가까운 것에서 끝나는 오브젝트를 거리별로 정렬합니다. 스카이 박스는 모든 불투명 한 객체와 모든 투명한 객체 사이에 그려집니다.
RenderType 태그 RenderType 태그는 셰이더를 미리 정의 된 여러 그룹으로 분류합니다. Is는 불투명 한 셰이더 또는 알파 테스트를받은 셰이더 등입니다. 셰이더 대체 (Shader Replacement) 및 경우에 따라 카메라의 심도 텍스처를 생성하는 데 사용됩니다.
DisableBatching 태그 일부 셰이더 (주로 오브젝트 공간의 정점 변형을하는 셰이더)는 호출 일괄 처리를 사용할 때 작동하지 않습니다. 이는 일괄 처리가 모든 지오메트리를 월드 공간으로 변환하여 "오브젝트 공간"이 손실되기 때문입니다.
DisableBatching 태그를 사용하여이를 활성화 할 수 있습니다. "True"(이 셰이더의 배치를 항상 비활성화 함), "False"(배치를 비활성화하지 않음, 기본값 임) 및 "LODFading"(LOD 페이드가 활성화 된 경우 일괄 처리 사용 안 함, 주로 나무에서 사용됨)입니다.
ForceNoShadowCasting 태그 ForceNoShadowCasting 태그가 주어지고 값이 "True"이면이 하위 셰이더를 사용하여 렌더링 된 객체는 결코 그림자를 투영하지 않습니다. 이는 투명한 객체에서 셰이더 대체를 사용하고 있고 다른 하위 셰이더에서 섀도우 패스를 상속하지 않을 때 주로 유용합니다.
IgnoreProjector 태그 IgnoreProjector 태그가 지정되고 값이 "True"이면이 쉐이더를 사용하는 객체는 프로젝터의 영향을받지 않습니다. 영사기가 영향을 미칠 수있는 좋은 방법이 없기 때문에 이것은 대부분 반투명의 객체에 유용합니다.
CanUseSpriteAtlas 태그 셰이더가 스프라이트를위한 것이라면 CanUseSpriteAtlas 태그를 "False"로 설정하고, 아트 래스터에 채워질 때 작동하지 않게됩니다 (Sprite Packer 참조).
PreviewType 태그 PreviewType은 머티리얼 인스펙터 미리보기에서 머티리얼을 표시하는 방법을 나타냅니다. 기본적으로 재질은 구체로 표시되지만 PreviewType은 "평면"(2D로 표시됨) 또는 "Skybox"(스카이 박스로 표시됨)로 설정할 수도 있습니다.
그랩패스 쉐이더, 그랩 텍스처셰이더 "Custom/JinhoBlurTest" { 속성 { _Color ("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} } 서브셰이더 { 태그
그랩패스{}
//화면을 뒤집는 냄비
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 램버트 알파: fade noshadow noambient novertexlights nolightmap nodynlightmap nodirlightmap nofog nometa noforwardadd nolppv noshadowmask
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 2.0
샘플러2D _MainTex;
Sampler2D _GrabTexture;
구조체 입력 {
고정2 uv_MainTex;
float4 screenPos;
};
고정4 _색상;
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_CBUFFER_START(속성)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_CBUFFER_END
void Surf (입력 IN, 입력 SurfaceOutput o) {
// 알베도는 색상별로 착색된 텍스처에서 나옵니다.
고정4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
//o.알베도 = c.rgb;
// 금속성과 부드러움은 슬라이더 변수에서 나옵니다.
float3 screenUV = IN.screenPos.rgb / IN.screenPos.a;
o.Emission = tex2D(_GrabTexture, screenUV.xy);
o.알파 = c.a;
}
ENDCG
}
대체 "확산"
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////없이 끝나기만 하는이더
셰이더 "Custom/SceneDistortinoSHader" { 속성 { _Color ("색상", 색상) = (1,1,1,1) _MainTex("알베도(RGB)", 2D) = "흰색" {} _광택("부드러움", 범위(0,1)) = 0.5 _Metallic ("금속성", 범위(0,1)) = 0.0 } 서브셰이더 { 태그 { "RenderType"="불투명" } LOD 200
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 nolight noambient// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
구조체 입력 {
float4 색상:색상;
};
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_CBUFFER_START(속성)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_CBUFFER_END
void Surf (입력 IN, 입력 SurfaceOutput o) {
}
float4 Lightingnolight(SurfaceOutput s, float3 lightDir, float atten) {
float4(1, 0, 0, 1)을 반환합니다.
}
ENDCG
}
FallBack "LegarcyShader/투명/Vertexlit"
}
완충하게 된 후 디스토션만 이더
셰이더 "Custom/SceneDistortinoSHader" { 속성 { _MainTex("알베도(RGB)", 2D) = "흰색"{} _RefStrength("_RefStrength", 범위(0, 10)) = 1
}
서브셰이더{
태그 { "RenderType" = "투명" "큐" = "투명" }
LOD 200
z쓰다
그랩패스{}
//화면을 캡쳐한다.
CGPROGRAM
// 물리적 기반의 표준 조명 모델이며 모든 조명 유형에 그림자를 활성화합니다.
#pragma 표면 서핑 nolight noambient alpha : fade
// 더 멋진 조명을 얻기 위해 셰이더 모델 3.0 타겟을 사용합니다.
#pragma 타겟 3.0
샘플러2D _MainTex;
Sampler2D _GrabTexture;
//화면을 캡쳐하고 있는 데이터
float _RefStrength;
구조체 입력 {
float2 uv_MainTex;
float4 색상:색상;
float4 screenPos; //화면캠페인계
};
// 이 셰이더에 대한 인스턴스 지원을 추가합니다. 셰이더를 사용하는 머티리얼에 대해서는 '인스턴싱 활성화'를 확인해야 합니다.
// 인스턴스화에 대한 자세한 내용은 https://docs.unity3d.com/Manual/GPUInstancing.html을 참조하세요.
// #pragma instancing_options는 균일한 크기 조정을 가정합니다.
UNITY_INSTANCING_CBUFFER_START(속성)
// 여기에 더 많은 인스턴스별 속성을 추가합니다.
UNITY_INSTANCING_CBUFFER_ENDvoid Surf (입력 IN, 입력 SurfaceOutput o) {
float4 ref = tex2D(_MainTex, IN.uv_MainTex);
float3 screenUV = IN.screenPos.rgb / IN.screenPos.a; //어느 방향에서 거래와 같은 uv값으로 반환
o.Emission = tex2D(_GrabTexture, screenUV.xy + ref.x * _RefStrength);
}
float4 Lightingnolight(SurfaceOutput s, float3 lightDir, float atten) {
float4(0, 0, 0, 1)을 반환합니다.
}
ENDCG
}
FallBack "LegacyShader/Transparent/Vertexlit"
}
플립북이더 float _Tile = round(_Time * _SequenceSpeed + _AddOffset); _Tile = fmod(_Tile, _XTiling * _YTiling); float2 TileCount = float2(1.0, 1.0) / float2(_XTiling, _YTiling); float TileY = abs((floor(_Tile * TileCount.x))); float TileX = abs(((_Tile - _XTiling * 바닥(_Tile * TileCount.x)))); float2 Out = (i.uv + float2(tileX, TileY)) * TileCount;
고정4 col = tex2D(_MainTex, Out);
이에 따른 처리 UnityObjectToClipPos(IN.vertex); 유니티 내부의 우주 매트릭스를 구성합니다. "mul(UNITY_MATRIX_MVP, IN.vertex)"와 같은 의미
v2f 정점 셰이더에서 조각 셰이더 구조로 MVP 모델 뷰 투영 매트릭스
SV System-Value(시스템 가치)
SV_포지션 SV_포지션 SVPosition이 더 에대한 입력으로 선언할 때 선형NoPerspective 또는 선형NoPerspectiveCentroid의 두 가지 보간 모드 중 하나를 허용할 수 있습니다. 이 모드에서는 다중 샘플 앤티 앨리어싱을 운동할 때 방사점 스냅된 xyzw 값을 제공합니다. 셰이더에서 사용되는 경우 SV_Position은 배열 위치를 설명합니다. 모든 셰이더에서 사용이 가능하여 0.5 오프셋의 무기 배열을 획득할 수 있습니다.
#프라그마
#pragma는 부품 제조 회사에서 부품을 축소할 수 있도록 하는 안전자입니다. 표준 보관소에 자신의 사무국 제작 기술이 지시하는 만큼 최대한의 기능을 제공할 수 있도록 허용해야 한다는 것입니다. 만약 다른 의미에서 해석할 수 없는 pragma 지시문을 만나면 무시하는 소스간 호환성 문제도 해결하고 있습니다.
-
#pragma 한 번 관리자에게 해당 파일이 즉시 작성되도록 합니다.
-
#pragma 주석() #pragma comment()는 부스로 사용하는 것이 가장 뚜렷합니다. 1 #pragma comment(lib, "*.lib") 많이 사용한다. 이 훈련은 의무를 링크한다는 것을 기억해 줍니다.
예) 아래 디버그는 프로젝트 설정에서 라이브러리를 링크하는 대신에 소스 코드를 통해 cv.lib를 링크할 수 있도록 해줍니다. 1 #pragma 주석(lib, "cv.lib")
- #pragma 경고 우려되는 자체 느낌 순간부터 특정 경고 메시지를 무시하는 리눅스입니다. 1 #pragma 경고(비활성화:4176) MS컴파일러에서 경의를 표하는 것은 자신의 고유번호를 말합니다. 파일에 소수의 소수의 자기 느낌 순간부터 4176 관련 경고 메시지를 출력하지 않게 됩니다.
#ifndef와 #pragma의 비교 #ifndef는 매크로 래퍼 방식을 이용하여 include를 귀찮게 할 때 사용합니다. 힘든 처리를 통해 특정 업무를 처리하고 싶다고 만족하지 않고 #endif까지의 코드가 화됩니다. 1 2 3 4 5 userClass.h #ifndef USERCLASS_H #define USERCLASS_H ....(userClass 선언).... #endif#ifndef는 전처리기가 파일을 계속 읽어들여 해당 헤더파일을 발견할 때마다 계속 읽는다. 모든 컴파일러에서 동작을 하지만 매번 헤더 파일을 열어서 define여부를 확인 해야 하기 때문에 느린 면이 있다. #pragma once 의 경우 컴파일러 전처리기 지시자로 한번 인식한 후 다음부터 같은 파일의 경우 파일을 읽기조차 하지 않는다 . 시간이 단축된다는 장점이 있지만, 특정 컴파일러에서만 동작을 한다. (Visual C++ 5.0 이상에서만 동작을 한다.) 구형 컴파일러에서도 동작하고 좀 더 범용적인 소스를 작성해야 하는 경우라면 #ifndef..#define 방식을 사용하고, 그 외의 경우에는 #pragma once를 사용하는 것을 추천한다.
외부 쉐이더 샘플
잔디 움직임 쉐이더
포워드 렌더링에서 Emissive컬러만 가져오기 https://forum.unity.com/threads/bloom-only-emissive-surfaces-in-forward-renderer.408645/
토글 이름 정의하기
Shader "Custom/Example" { Properties { [Toggle(RED)] _Invert("Red ?" , Float) = 0 }
SubShader { CGINCLUDE #include "UnityCG.cginc"
fixed4 frag(v2f_img i) : SV_Target
{
fixed4 col = fixed4(1, 1, 1, 1);
#ifdef RED
col.y = 0;
col.z = 0;
#endif
return col;
}
ENDCG
Pass
{
CGPROGRAM
#pragma vertex vert_img
#pragma fragment frag
#pragma multi_compile _ RED
ENDCG
}
} }
랜덤 타일링 마스크1. 셰이더 "Custom/Test2" { 2. 속성 { 3. _Tex1("텍스처 1", 2D) = "흰색" {} 4. _Mask("마스크", 2D) = "흰색" {} 5. } 6. 서브셰이더 { 7. 태그 { "RenderType"="불투명" } 8. LOD 200 9. 10. CG프로그램 11. #프라그마 서피스 서프 램버트 12. 13. 샘플러2D _Tex1, _Mask; 14. 15. 구조체 입력 { 16. float2 uv_Tex1; 17. float2 uv_Mask; 18. }; 19. 20. void Surf (Input IN, inout SurfaceOutput o) { 21. 22. half4 마스크 = tex2D(_Mask, IN.uv_Mask * 0.5); 23. half4 outTex; 24. 25. float2 uvTexRot = IN.uv_Tex1 - 0.5; 26. 27. if (마스크.r <= 0.3) { 28. //90도 회전 29. float2x2 회전 매트릭스 = float2x2( 0, 1, -1, 0); // 90도 30. uvTexRot = mul(uvTexRot, 회전매트릭스); 31.uvTexRot.xy += 0.5; 32. outTex = tex2D (_Tex1, uvTexRot); 33. } else if (mask.r <= 0.6 ) { 34. // 180도 회전 35. float2x2 회전 매트릭스 = float2x2( -1, 0, 0, -1); // 180도 36. uvTexRot = mul(uvTexRot, 회전매트릭스); 37.uvTexRot.xy += 0.5; 38. outTex = tex2D (_Tex1, uvTexRot); 39. } else if (mask.r <= 0.8 ) { 40. // 270도 회전 41. float2x2 회전 매트릭스 = float2x2( 0, -1, 1, 0); // 270도 42. uvTexRot = mul(uvTexRot, 회전매트릭스); 43.uvTexRot.xy += 0.5; 44. outTex = tex2D (_Tex1, uvTexRot); 45. } 그렇지 않으면 { 46. // 0도 회전 47. outTex = tex2D (_Tex1, IN.uv_Tex1); 48. } 49. 50. o.알베도 = outTex.rgb; 51.o.Alpha = outTex.a; 52. } 53. 엔드CG 54. } 55. 폴백 "확산" 56. }
비의 효과
유니티 블룸이 더 (이 안에 들어있기를 추구하는 것.)
https://docs.unity3d.com/Manual/GraphicsCommandBuffers.html
렌더 처리 데이터 https://docs.unity3d.com/ScriptReference/RenderTextureFormat.html
버텍스 추출들어가는 효과가 있습니다 https://blog.csdn.net/wwlcsdn000/article/details/78895272
모션벡터 http://www.klemenlozar.com/frame-blending-with-motion-vectors/ https://www.youtube.com/watch?v=zykKhdMUTwg
원활한 개요
https://www.youtube.com/watch?v=e4bvwoSGD6k
그래픽스펜더 파이프라인
링크
빌트인이더 헬퍼
https://docs.unity3d.com/Manual/SL-BuiltinFunctions.html
빌트인이 더
https://docs.unity3d.com/kr/current/Manual/SL-UnityShaderVariables.html
유니티 Mathf
https://docs.unity3d.com/kr/530/ScriptReference/Mathf.html
HLSL 내장함수http://egloos.zum.com/indra207/v/4856054
ShaderCod (유니티 내장 쉐이더 설명)
http://wiki.unity3d.com/index.php?title=Shader_Code
그래픽스 커맨드 버퍼
https://docs.unity3d.com/kr/530/Manual/GraphicsCommandBuffers.html
카메라 이벤트
https://docs.unity3d.com/kr/530/ScriptReference/Rendering.CameraEvent.html
Dirext Function 라이브러리
http://developer.download.nvidia.com/CgTutorial/cg_tutorial_appendix_e.html
엔비디아 CG 라이브러리
http://developer.download.nvidia.com/cg/index_stdlib.html
여러 셰이더 프로그램 배리언트 만들기 (Making Multiple shader program variants)
https://docs.unity3d.com/kr/current/Manual/SL-MultipleProgramVariants.html
커맨드 버퍼 Bbuffer0~3사용하는 방법
SSR문서
http://www.kode80.com/blog/2015/03/11/screen-space-reflections-in-unity-5/
Material properties and the GI system https://docs.unity3d.com/kr/current/Manual/MetaPass.html
흑백 쉐이더 만들기
RGB => AlphaTest 쉐이더
자라나는 나무 쉐이더
유니티 렌더링 튜토리얼 https://catlikecoding.com/unity/tutorials/
Unity3D shader 저사양 굴절 표현하기
float3 viewD = viewDirection; float2 viewDMnormalD = (viewDnormalDirection).xy; float2 uv_01 = i.uv0; float2backmove=(uv_01.xy+((1.0 - viewD.xy)normalize(distance(objPos.xyz,_WorldSpaceCameraPos.xyz)))+(-1.0)+float2(((viewDMnormalD.x_Distortion)+uv_01.x),((viewDMnormalD.y_Distortion)+uv_01.y)));
Unity 후처리 모션블러 효과
float4 pix = tex2D(_MainTex, i.uv); float2 dir = 0.5 - i.uv; float dist = length(dir); dir /= dist; float4 sum = pix; sum += tex2D(_MainTex, i.uv + dir * -0.08 * _SampleDist); sum += tex2D(_MainTex, i.uv + dir * -0.05 * _SampleDist); sum += tex2D(_MainTex, i.uv + dir * -0.03 * _SampleDist); sum += tex2D(_MainTex, i.uv + dir * -0.02 * _SampleDist); sum += tex2D(_MainTex, i.uv + dir * -0.01 * _SampleDist);
sum *= 1.0 / 6.0; float t = saturate(dist * _SampleStrength); pix = lerp(pix, sum, t); return pix;
유니티 쉐이더 알고리즘.렌더링 관련 이슈 주요 셰이더 최적화 7가지 프레임 단위에서는 게임 코드보다 셰이더 코드가 수행하는 작업이 훨씬 더 많습니다. 다음의 최적화를 사용하여 성능/FPS 속도를 쾌적하게 유지할 수 있습니다.
- 비상수 연산을 최소화하세요. 상수 또는 "dynamic uniforms"(예: x=4/33, x=4xsin(24))를 사용하세요.
- 스칼라 값(float, int)을 벡터 값(float3, float4)보다 먼저 곱하세요.
- 알파테스트의 경우를 포함하여 가급적 폐기 명령을 지양하세요(주로 모바일에 적용됨). 오버드로우에 유의하세요.
- 가능한 한 버텍스 셰이더 내로 계산을 제한하세요.
- 벡터 작동이 결과의 모든 구성요소를 사용하지 않는 경우, 가능한 한 벡터 작동에 대한 쓰기 마스크를 지정하세요.
- 동적으로 설정된 값/non-uniforms(if-else, loops)에 기반하여 브랜칭을 수행하지 마세요.
- 작동(예: discard(), floor() 등)이 렌더러 모델(OpenGL 2, OpenGL 3, OpenGL ES 등)과 하드웨어에 미치는 영향을 확인하세요.
텍스처 압축시 바이트 배분 순서 A > G > R = B
선형 렌더링에서 주의할점.
디퓨즈, Emission 컬러와 같이 두루뭉술 하면서 눈으로 보면서 해야 하는 것들은 SRGB를 사용. (단 SRGB처리 했을 때 알파값은 감마보정으로 유지되기 때문에 후처리를 해줘야 함.) 후처리 계산식 : power(rgb, 1/2.2)??
툴로 인해서 정확하게 추출해야 하는 것들(노멀, 메탈릭, 스무스니스 등)은 RGB를 사용.
엠비언트 컬러 제어하기 (모바일 최적화 할때 씀.)
fixed4 ambient = UNITY_LIGHTMODEL_AMBIENT; //엠비언트 컬러를 직접적으로 사용. https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html (참고링크)
Unity API의 RenderSettings.ambientLight로 Scene에 동적으로 제어가 가능함. Toggle로 해당 항목한 필요한 상황에 활성화 해 사용할 수 있음. 다만 모든 Scene의 오브젝트가 이에 대한 처리가 되어 있어야 함. https://docs.unity3d.com/ScriptReference/RenderSettings-ambientLight.html (참고링크)
fixed 와 Half의 차이점.
또 플랫폼마다 다르게 동작하는 문제가 있다. 바로 shader에서 float 타입 변수를 선언할 때마다 결정하는 것이 정확도이다. 지금까지는 이걸 굳이 신경 안써도 잘 동작해서, 왜 이런게 존재하나 했었는데. 최근에 이 차이로 인한 문제를 경험했다.
Specular와 Overlight를 지원하는 shader를 구현하여 모바일 빌드를 했는데, Android와 iOS의 화면이 다르다. Android에서는 정상적으로 출력되는데 iOS에서는 하얗게 타서 나오는 것이다. 원인을 찾아보니, spec과 glow를 처리하는 코드에서 fixed 타입 변수를 사용했는데, 이 타입 변수는 정확도 뿐만 아니라 표현할 수 있는 범위도 매우 제한적이어서, 정확한 계산이 안 되는 것이다. 그런데 이 문제는 iOS에서만 발생한다. 즉 각 플랫폼마다 또 동작이 다르다.. (이구~~~)
문서를 보면, fixed는 -2 ~ + 2까지만 표현되고, half는 2**-15 ~ 2**+15 까지 표현된다고 한다. 보통 spec과 glow는 큰 값이 들어오므로, 이들의 외부 parameter 선언을 half로 선언하니 문제가 해결되었다.