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

Z는 공간에서 Z축 위치를 뜻하며,Buffer는 카메라와 물체의 거리를 저장하는 메모리 공간을 의미합니다.

처음엔 초록색을 그리고, 그다음엔 빨간색을 그리고, 그다음은 파란색순으로 색위를 덫칠한다고 생각해야합니다.

위 과정으로 화면에  컬러들이 표시된다고 상상하면 됩니다.

Unity는 Cull , Zwrite, Ztest의 세가지 옵션을 제공합니다.

ZTest는 7가지 값이 있습니다.

ZTest Less | Greater | LEqual | GEqual | Equal | NotEqual | Always

기본값은 LEqual  (이미 그려진 오브젝트와 거리가 같거나 더 가까운 경우에 그립니다. 그보다 먼 경우에는 오브젝트로 숨깁니다)입니다.

Ztest와 Cull 를 이용하면 재미있는 형태를 만들어 낼수 있다.

Unity에 처리 대기열을 Render Queue라고 합니다.

Render Queue를 수정하는 방법은 두가지 방법이 있습니다.

위처럼 material inspector의 숫자를 변경하여 순서를 정하거나, 

아래 셰이더 Tag를 이용하는 방법입니다.

Queue의 순서는 다음과 같습니다.

"Queue"= "배경" 범위는 0 ~ 1499입니다. 기본값은 1000입니다.
"Queue"= "지오메트리" 1500 ~ 2399 범위 기본값은 2000입니다.
"Queue"= "AlphaTest" 2400 ~ 2699 범위 기본값은 2450입니다.
"Queue"= "투명"  2700 ~ 3599 범위 기본값은 3000입니다.
"대기열"= "오버레이" 범위는 3600에서 5000까지입니다. 기본값은 4000입니다.

 SubShader
    {
        Tags 
        { 
            "RenderType"="Opaque"
            "Queue" = "Transparent"
        }
        
            ZWrite Off
            Blend SrcAlpha OneMinusSrcAlpha //전통적인 투명
            //Blend One OneMinusSrcAlpha // 미리 곱해진 투명
            //Blend One One //ADD
            //Blend OneMinusDstColor One // SOFT ADD
            //Blend DstColor Zero // MULTIPLY
            //Blend DstColor SrcColor // 2X MULTIPLY
            //Blend SrcColor One //OVERLAY
            //Blend OneMinusSrcColor One //SOFT LIGHT
            //Blend Zero OneMinusSrcColor //SUBTRACT


            BlendOp Add  //Default Value
            //BlendOP Sub
            //BlendOP Max
            //BlendOP Min
            //BlendOP RevSub

        Pass

코드는 위처럼 만들어지게 되고, 그 결과는 아래와 같은 순서로 됩니다.

유니티 도움말 참고: docs.unity3d.com/Manual/SL-Blend.html

Unity Shaders con CG/HLSL y Shader Graph 강의를 대충듣고 작성된겁니다.

(원어가 스페인어이고 이를 번역한 영어를 또 해석한거라 오역이 있을수 있습니다.)

물체가 화면에 뿌려지는 과정은 위와 같은과정을 거친다.

unity 쉐이더는 CG 코드를 사용한다.

CG언어는 NVIDIA와 마이크로소프트의 협력하여 만든 언어이다.

그리고 이것은 HLSL가 비슷한 구문으로 사용된다.

GLSL- OpenGL Shading Language

HLSL- High Level Shader Language

HLSL과 CG는 동일한 언어이지만 다른 이름을 반영합니다.

셰이더가 CG 언어로 작동하는 이유 HLSL과 GLSL을 모두 컴파일 할 수 있기 때문입니다.

1. Shader의 이름을 정의합니다.

2. Shader 속성을 정의합니다.

3. Shader 시작과끝

4. 하나 이상의 pass를 설정합니다.

반투명과 투명픽셀의 블랜딩을 설정하여 투명단계를 설정합니다.

Shader의 모든 속성은 쉐이더랩 언어로 선언됩니다.

이 모든것은 CG언어가 GPU에서 실행됩니다.

Unity는 두가지를 선택할수 있는 언어 옵션을 제공합니다.

Surface shader는 빠르고 쉽게 접근이 가능하지만 갖혀진 틀에서 작업해야하며,

Vertex/Fragment Shader는 좀더 많은 범위에서 조작이 가능해집니다.

속성은 8가지로 작성될수 있습니다.

투명과 불투명을 설정합니다. (이외에 뭐라 설명하는데 이해를 못했네요.)

투명패스, 컬러패스, 그림자패스등 렌더 패스를 나타냅니다.

패스가 많을수록 드로우콜이 늘어나게 됩니다.

Fallback은 subshader가 실패할 경우 사용해야 하는 기본 셰이더 이름에 해당합니다.

(만든 셰이더가 제대로 작동하지 않는다면 다른 셰이더를 사용하라는 일종에 대비에 해당됩니다.)

구조체 사용변수

정점 셰이더는 3D 모델의 각 정점에서 실행되는 프로그램입니다.

객체의 정점 위치를 "클립공간" "투사공간"이라고 불리는 자표계로 변환할수 있습니다.

물체에 텍스쳐를 붙이고 싶다면 우리는 UV좌표를 갖을 필요가 있습니다.

Fragment Shader는 객체가 화면에 차지하는 각 픽셀에서 실행되는 프로그램입니다.

Fragment Shader는 최종적으로 화면에 뿌려지는 픽셀이라고 설명할수 있습니다.

그래서 우리는 원하는 결과를 화면에 물체를 뿌리기 위해서는  Vertex Shader와 Fragment Shader 둘다 필요합니다.

Unity에서 셰이더를 생성하기위한 표준 언어가 HLSL입니다.

Unity에는 모바일 장치에서 더 나은 작동을 허용하는 몇 가지 추가 데이터 유형이 위처럼 있습니다.

더 높은 정밀도로 데이터 유형으로 작업 할 때 GPU 계산이 높을수록 그러므로,모바일 장치가 더 뜨거워지고 배터리가 더 많이 소모됩니다.

Float는 고정밀 32 비트 데이터 유형입니다.
Half는 16 비트 중간 정밀도 데이터 유형입니다.
fixed는 낮은 정밀도의 11 비트 데이터 유형입니다.

벡터와 행열

텍스처의 데이터 유형의 예

3D 물체가  화면에 뿌려주는 과정

float4x4는 UNITY_MATRIX_MVP 행렬에 해당하는 세 개의 개별 행렬이 결합 된 형태입니다.

로컬, 월드, 뷰, 프로젝션 

Local space : 물체의 중심을 기준으로 정의됩니다.

POSITION 시맨틱은 꼭지점 값을 이야기 합니다.

float4 vertex : POSITION 의미는 "vertex"변수에 모델의 초기 정점 위치를 저장하여 셰이더에 할당합니다.

World space: 포인트의 위치는 그리드의 중심을 기준으로 정의됩니다.

View space: 공간에서 한 지점 사이의 거리 좌표에 해당 카메라 뷰의 포인트입니다. 카메라 시선이라고 생각하면됩니다.

Projection space: 클립스페이스이다.

카메라 렌즈의 중앙에있는 거리와 관련하여 클립 공간이라고도하는 투영 공간에서 좌표 변환 프로세스는 카메라 Frustum와 관련하여 수행됩니다.

Frustum: 근거리 클리핑 평면, 원거리 클리핑 평면 및 시야로 정의됩니다.

SV_POSITION 의미론은 픽셀의 위치에 해당합니다.

(유니티정의:두 클리핑 평면과 경계선에 의해 잘린 피라미드의 형상이 되며, 이것을 뷰 Frustum이라고 합니다.)

UnityObjectToClipPos ()는 오브젝트를 로드할 때 정점의 위치는 오브젝트 공간에 로드됩니다

물체를 로드하는 방식은 여러가지 이나, 가장 적절하고 간단한 방법은 포함 된 기능을 사용하는 것입니다.

GI Cache를 지우고 해봅니다.

이게 빌드 속도를 높이려고 만든것인데, 간혹 제대로 조명이 제대로 안나온다면 이걸 리셋해주면 해결이 됩니다.

라이트맵이 제대로 반영이 안되거나 할때도 한번씩 눌러줍니다.

그외에 빌드 옵션이 잘못된 경우도 있으니 잘 확인해야합니다.

{

	int[] array = new int[7];    
	public int[] GrobA;
	public int[] GrobB;

	int tru = 0;
    
    // Start is called before the first frame update
    void Start()
    {
	    AAA();
	    BBB();
	    CCC();
    }

	void AAA()
	{
		print("-------------start--------------");
		print("-------------45개랜덤--------------");
		for (int i = 1; i < array.Length ; )
        	{
			//array[i] = i;
				int result = Random.Range(1, 45);
				if(tru != result)
				{
					print(result);
					i =i+1;
				}

	        tru = result;
        }

	}
	
	void BBB()
	{
		print("-------------GrobA 랜덤--------------");
        
		for (int i = 1; i < array.Length ;)
		{
			//array[i] = i;

            
			int result = Random.Range(1, GrobA.Length);

			if(tru != result)
			{
				print(GrobA[result]);
				i =i+1;
			}
               
			tru = result;

		}
		
	}

    
	void CCC()
	{
		print("-------------GrobB 랜덤--------------");
        
        
		for (int i = 1; i < array.Length ; )
		{
			//array[i] = i;

            
			int result = Random.Range(1, GrobB.Length);

			if(tru != result)
			{
				print(GrobB[result]);
				i =i+1;
			}
               
			tru = result;

		}  
		
	}

}

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class TEST_Num : MonoBehaviour
{
    private int[] numbers = Enumerable.Range(1, 45).ToArray();
    private List<int> selectedNumbers = new List<int>();

    public int SetNumber = 1;

    [SerializeField]
    private int[] desiredNumbers = new int[] { };

    private void Start()
    {
        SelectNumbers();
        DisplaySelectedNumbers();
    }

    private void SelectNumbers()
    {
        System.Random random = new System.Random();

        while (selectedNumbers.Contains(0) || selectedNumbers.Count < 6)
        {
            selectedNumbers.Clear();

            for (int i = 0; i < Math.Min(desiredNumbers.Length, SetNumber); i++)
            {
                int requiredNumberIndex = Array.IndexOf(numbers, desiredNumbers[i]);

                if (random.NextDouble() < 0.7)
                {
                    selectedNumbers.Add(desiredNumbers[i]);
                    numbers[requiredNumberIndex] = numbers[numbers.Length - i - 1];
                }
            }

            for (int i = Math.Min(desiredNumbers.Length, 3); i < 6 && selectedNumbers.Count < 6;)
            {
                int index = random.Next(0, numbers.Length - i);
                int selectedNumber = numbers[index];

                if (selectedNumber == 0)
                {
                    continue;
                }

                selectedNumbers.Add(selectedNumber);
                numbers[index] = numbers[numbers.Length - i - 1];
                i++;
            }
        }
    }

    private void DisplaySelectedNumbers()
    {
        string result = string.Join(", ", selectedNumbers.OrderBy(x => x));
        Debug.Log(result);
    }
}

- 맥스에서 익스포트시 휴머노이드에서 캐릭터의 엄지손가락이 제대로 동작하지 않는 문제가 발생하였습니다.

- 이리저리 테스트해본 결과 휴머노이드는 IK방향이 정해져있어서 손가락의 경우는 한쪽 방향으로 움직이게 만들어놨기 때문이라. 손가락 본을 틀어 놔야지 정상적으로 작동한다는것을 알았습니다.(이건 또 버전별로 좀 다릅니다.-_-;)

- 그외 휴머노이드는 덩치가 다른 캐릭터가 있다면 물건을 양손으로 잡는데 문제가 있습니다. (팔벌리는 거리가 비례적으로 늘기 때문입니다.)

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class PostProcessingTest : MonoBehaviour
{
    public Volume Volume;
    public Bloom Bloom;
    public ChromaticAberration ChromaticAberration;

    // Start is called before the first frame update
    void Awake()
    {
        Volume.profile.TryGet(out Bloom);
        Volume.profile.TryGet(out ChromaticAberration);
    }

    // Update is called once per frame
    float Value;
    void Update()
    {
        Value += Time.deltaTime;

        Bloom.intensity.value = (Mathf.Sin(Value) * 0.5f + 0.5f) * 100;
        ChromaticAberration.intensity.value = (Mathf.Sin(Value) * 0.5f + 0.5f);
    }
}

원본:    cafe.naver.com/unityhub/104284 

Shader "ryoo/RyooSpecularShaderForwardAddooo" 

{ 

	Properties 
	{
	
		_DiffuseTex ("Texture", 2D) = "white" {} 
		_Color ("Color", Color) = (1,0,0,1) 
		_Ambient ("Ambient", Range (0, 1)) = 0.25 
		_SpecColor ("Specular Material Color", Color) = (1,1,1,1) // 스페큘러 컬러
		_Shininess ( "Shininess", Float) = 10 // 스페큘러 강도
	}


	SubShader
	{

		Tags { "LightMode" = "ForwardBase" } 
		LOD 100

		Pass
		{

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

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

			struct v2f // v2f struct(구조체)에 변수를 추가하고, v2f를 통해 프레그먼트 셰이더에 전달
			{
				float2 uv : TEXCOORD0; 
				float4 vertexClip : SV_POSITION; 
				float4 vertexWorld : TEXCOORD2; // 프레그먼트 셰이더에서 광원 방향 벡터 계산
				float3 worldNormal : TEXCOORD1; 
			}; 

			sampler2D _DiffuseTex; 
			float4 _DiffuseTex_ST; 
			float4 _Color; 
			float _Ambient; 
			float _Shininess; 
			
			v2f vert (appdata v) //정점 셰이더 부분
			{
				v2f o;
				o.vertexClip = UnityObjectToClipPos(v.vertex); 
				//o.vertexWorld = mul(unity_ObjectToWorld, v.vertex);
				o.vertexWorld = UnityObjectToClipPos(v.vertex);
				o.uv = TRANSFORM_TEX(v.uv, _DiffuseTex); //텍스쳐 영역
				float3 worldNormal = UnityObjectToWorldNormal(v.normal); 
				o.worldNormal = worldNormal;
				return o; 
			} 

			float4 frag (v2f i) : SV_Target //프레그먼트 셰이더 부분
			{
				//정규화된 월드 공간의 노멀 벡터
				float3 normalDirection = normalize( i.worldNormal); 
				
				// 정규화된 뷰 방향 벡터
				float3 viewDirection = normalize(UnityWorldSpaceViewDir(i. vertexWorld)); 
				
				// 정규화된 광원 방향 벡터
				float3 lightDirection = normalize(UnityWorldSpaceLightDir(i. vertexWorld));
				//텍스쳐 영역
				float4 tex =tex2D(_DiffuseTex, i.uv); 
				
				// 디퓨즈(람버트) 구현
				float nl = max(_Ambient, dot(normalDirection, lightDirection));
				float4 diffuseTerm = nl * _Color * tex * _LightColor0; 
	
				//스페큘러(퐁) 구현
				float3 reflectionDirection = reflect(-lightDirection, normalDirection); 
				float3 specularDot = max(0.0, dot(viewDirection, reflectionDirection)); 
				float3 specular = pow(specularDot, _Shininess);
				float4 specularTerm = float4( specular, 1) * _SpecColor * _LightColor0; 
				
	
				float4 finalColor = diffuseTerm + specularTerm;
				return finalColor; 
			} 
			ENDCG
		}

		Pass // 추가 광원을 지원하기 위해서 같은걸 복사하고 몇가지만 수정
		{

			Tags { "LightMode" = "ForwardAdd" } // 추가 광원을 지원하기 위함.
			Blend One One
			CGPROGRAM 
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile_fwdadd 
			#include "UnityCG.cginc" 
			#include "UnityLightingCommon.cginc" 
			
			struct appdata 
			{
				float4 vertex : POSITION; 
				float3 normal : NORMAL;
				float2 uv : TEXCOORD0; 
			}; 

			struct v2f 
			{
			float2 uv : TEXCOORD0; 
			float4 vertexClip : SV_POSITION; 
			float4 vertexWorld : TEXCOORD2;
			float3 worldNormal : TEXCOORD1; 
			}; 
			
			sampler2D _DiffuseTex; 
			float4 _DiffuseTex_ST; 
			float4 _Color; 
			float _Ambient;
			float _Shininess; 
			
			v2f vert (appdata v) 
			{
				v2f o;
				o.vertexClip = UnityObjectToClipPos(v.vertex); 
				o.vertexWorld = mul(unity_ObjectToWorld, v.vertex); 
				o.uv = TRANSFORM_TEX(v.uv, _DiffuseTex); 
				
				float3 worldNormal = UnityObjectToWorldNormal(v.normal); 
				o.worldNormal = worldNormal;
				return o;
			} 
			
			float4 frag (v2f i) : SV_Target 
			{
			float3 normalDirection = normalize( i.worldNormal); 
			
			// 정규화된 뷰 방향 벡터
			float3 viewDirection = normalize( UnityWorldSpaceViewDir(i.vertexWorld)); 
			
			// 정규화된 광원 방향 벡터
			float3 lightDirection = normalize(UnityWorldSpaceLightDir(i.vertexWorld));
			
			//텍스쳐 영역
			float4 tex = tex2D(_DiffuseTex, i.uv); 
			
			// 디퓨즈(람버트) 구현
			float nl = max(0.0, dot(normalDirection, lightDirection)); // Ambient를 제외시킨다. 포함시키면 빛이 더해져서 너무 밝게 나오기 때문에 0으로 셋팅한다.
			float4 diffuseTerm = nl * _Color * tex * _LightColor0; 
			
			//스페큘러(퐁) 구현
			float3 reflectionDirection = reflect(-lightDirection, normalDirection); 
			float3 specularDot = max(0.0, dot(viewDirection, reflectionDirection)); 
			float3 specular = pow( specularDot, _Shininess); 
			//여기까지 퐁
			float4 specularTerm = float4( specular, 1) *_SpecColor * _LightColor0; 
			float4 finalColor = diffuseTerm + specularTerm;
			return finalColor; 
			}
			ENDCG
		}

	}

}

참고서적: 유니티 물리 기반 셰이더 개발 

Shader "ryoo/RyooSpecularzero" 

{ 

	Properties 
	{
	
		_DiffuseTex ("Texture", 2D) = "white" {} 
		_Color ("Color", Color) = (1,0,0,1) 
		_Ambient ("Ambient", Range (0, 1)) = 0.25 
		_SpecColor ("Specular Material Color", Color) = (1,1,1,1) // 스페큘러 컬러
		_Shininess ( "Shininess", Float) = 10 // 스페큘러 강도
	}

	SubShader
	{

		Tags { "LightMode" = "ForwardBase" } 
		LOD 100

		Pass
		{

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

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

			struct v2f // v2f struct(구조체)에 변수를 추가하고, v2f를 통해 프레그먼트 셰이더에 전달
			{
				float2 uv : TEXCOORD0; 
				float4 vertexClip : SV_POSITION; 
				float4 vertexWorld : TEXCOORD2; // 프레그먼트 셰이더에서 광원 방향 벡터 계산
				float3 worldNormal : TEXCOORD1; 
			}; 

			sampler2D _DiffuseTex; 
			float4 _DiffuseTex_ST; 
			float4 _Color; 
			float _Ambient; 
			float _Shininess; 
			
			v2f vert (appdata v) //정점 셰이더 부분
			{
				v2f o;
				o.vertexClip = UnityObjectToClipPos(v.vertex); 
				o.vertexWorld = mul(unity_ObjectToWorld, v.vertex); 
				o.uv = TRANSFORM_TEX(v.uv, _DiffuseTex); //텍스쳐 영역
				float3 worldNormal = UnityObjectToWorldNormal(v.normal); 
				o.worldNormal = worldNormal;
				return o; 
			} 

			float4 frag (v2f i) : SV_Target //프레그먼트 셰이더 부분
			{
				//정규화된 월드 공간의 노멀 벡터
				float3 normalDirection = normalize( i.worldNormal); 
				
				// 정규화된 뷰 방향 벡터
				float3 viewDirection = normalize(UnityWorldSpaceViewDir(i. vertexWorld)); 
				
				// 정규화된 광원 방향 벡터
				float3 lightDirection = normalize(UnityWorldSpaceLightDir(i. vertexWorld));
                
				//텍스쳐 영역
				float4 tex =tex2D(_DiffuseTex, i.uv); 
				
				// 디퓨즈(람버트) 구현
				float nl = max(_Ambient, dot(normalDirection, lightDirection));
				float4 diffuseTerm = nl * _Color * tex * _LightColor0; 
	
				//스페큘러(퐁) 구현
				float3 reflectionDirection = reflect(-lightDirection, normalDirection); 
				float3 specularDot = max(0.0, dot(viewDirection, reflectionDirection)); 
				float3 specular = pow(specularDot, _Shininess);
				float4 specularTerm = float4( specular, 1) * _SpecColor * _LightColor0; 
				
	
				float4 finalColor = diffuseTerm + specularTerm;
				return finalColor; 
			} 
			ENDCG
		}


	}

}

참고서적: 유니티 물리 기반 셰이더 개발 

팁들을 모아 봅니다.

시간의 속도를 조절하기(sine그래프를 빠르게)

UV를 이용한 연출 효과

참고: www.youtube.com/watch?v=AooFfmQ_Svo

옵션 설명

docs.unity3d.com/Packages/com.unity.postprocessing@2.3/manual/Ambient-Occlusion.html

특정 물체에 포스트 프로세싱을 안하려면

- 포스트 프로세싱이 된 카메라 하단에 카메라를 하나 넣고 다음과 같이 설정합니다.

- 하지만 문제가 있습니다. 위 설정은 카메라 순서를 무시합니다.

- 이럴때는 아래와 같이 설정하면 됩니다.

Terrain 제작시에 라이트맵이 되질 않아서 좀 헤메었습니다.(잊지않도록 메모 해봅니다.)

다음과 같은 사항에 유의합시다.

- Terrain 자체를 Static으로 처리가 되었는지 확인합니다.

- 나무 Prefab이 Static으로 되어있는지 확인을 합니다.(이걸 발견못해서...)

- 나무의 경우 라이트맵을 구운후에 캐스트 쉐도우를 꺼주면 그만큼 Batches에 도움이됩니다.(너무 당연한가요..)

- mesh에 Generate Lightmap UVs가 되어있는지 확인한다.(이건 맥스에서 펴와도 됩니다.)

Shader "ryoo/DiffuseShader1"
{
    Properties
    {
        _DiffuseTex ("Texture", 2D) = "white" {}
        _Color("Color",Color) = (1,0,0,1)
        _Ambient("Ambient",Range(0,1)) = 0.25
    }
    SubShader
    {
        Tags { "LightMode"="ForwardBase" }
        LOD 100

        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"
            #include "UnityLightingCommon.cginc"

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

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

            sampler2D _DiffuseTex;
            float4 _DiffuseTex_ST;
            fixed4 _Color;
            float _Ambient;
            

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = TRANSFORM_TEX(v.uv, _DiffuseTex);
                float3 worldNormal = UnityObjectToWorldNormal(v.normal);
                //o. worldNormal = worldNormal;
                
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 normalDirection = normalize(i.worldNormal);
                
                float4 tex = tex2D(_DiffuseTex, i.uv);
                
                float nl = max(_Ambient, dot(normalDirection, _WorldSpaceLightPos0.xyz));
                float4 diffuseTerm = nl * _Color * tex *_LightColor0;
                
                return diffuseTerm;
            }
            ENDCG
        }
    }
}

참고서적: 유니티 물리 기반 셰이더 개발 

자주 헛갈려서 그림으로 정리해봤습니다.

Reflection Probe를 이용해서 거울 효과를 만들어보려고했는데, 인터넷에 있는 영상을 따라서 물체에 중심을 두고 시도하였습니다.

하지만, 이상하게 물체들이 반사가 되긴하지만 엄청나게 크고 이상한 위치에 있었습니다.

이리저리 테스트를 하다가 알게되었네요.

카메라의 위치와 Reflection Probe와 관계가 있습니다.

Reflection Probe는 카메라 포지션의 Y값의 반대가 되어야 정위치에 온다는걸 알았네요.

물체자체가 리플렉션을 갖을때는 그자신이 움직이기에 상관이없지만 이렇게 카메라의 시점에서 보면 다른게 당연하겠네요.

예전에 축구게임할때랑 반복작업할때 많이 써먹었는데, 오랜만에 만지니깐 기억이 가물해서 간단 정리해봅니다.

www.autohotkey.com/

참고)

pnal.kr/16

예제1) 마우스가 랜덤으로 특정 구역에서 클릭합니다.

^f1:: // ctrl+f1
loop
{
CoordMode,Mouse,Screen// 절대 좌표이다. Screen
random,x,1400,1740
random,y,250,660
random,t,5000,8000

MouseClick, Left, x, y // 마우스 클릭
MouseMove, x, y // 마우스이동
sleep, t // 딜레이시간
}
Reload
^f2::Pause

예제2) 마우스 클릭하면 좌표가 나옵니다.

^F2::

loop 1

{

MouseGetpos, vx, vy

MsgBox, 현재 마우스 좌표는 %vx% , %vy% 입니다 

return

}

예제3) if 문

MsgBox, 4, 제목, 매크로시작 
IfMsgBox, Yes
{
    MsgBox, 예를 눌렀습니다. // 여기에 매크로 내용을 넣음
}
IfMsgBox, No
{
    MsgBox, 아니오를 눌렀습니다. // 여기에 매크로 내용을 넣음
}

예제4) 버튼

gui, add, text, x57 y10 w80 h20, 매크로
gui, add, text, x65 y30 w50 h20 vA, 0초
gui, add, Button, x20 y50 w110 h20, 시작
gui, add, Button, x20 y80 w110 h20, 종료
gui, Show

return

Button시작:
{
 
     time:=0
  
  loop{
  
      time:=time+1
      sleep,1000
     
      guicontrol,,A,%time%초

     }
  
}

Button종료:
{
 
     ExitApp
  
}

예제4) 버튼 눌러서 단축키를 실행

Gui, Font, S20 CBlue Bold, Verdana ;폰트크기컬러
gui, add, text, x57 y10 w180 h20, 매크로

Gui, Font, S14 C009900 W500, Verdana ;폰트크기컬러
gui, add, Button, x20 y50 w110 h20, 시작
gui, add, Button, x20 y80 w110 h20, 종료
gui, Show

return

Button시작:
GuiControl, Disable, 시작 ;버튼이 비활성화됩니다.
{
#IfWinActive ahk_class OsWindow ;OsWindow에서만 작동한다.특정윈도우에서만 동작 다른곳에서는 작동안함.

F12:: ;일시중지
	
SUSPEND  ;일시중지 명령어 다시 F12를 누르면 정상화
	
return



q::

	send,{2}
	send,{RButton}
	sleep,300
	
return
	
r::

	send,{2}
	send,{RButton}
	sleep,300

return


w::
	
	send,{Space}
	sleep,100
	
return


}
return

Button종료:
{
 
     ExitApp
  
}

float3 UnityObjectToWorldDir(in float3 dir) 객체 공간의 방향을 취해 월드 공간에서의 방향 값으로 변환해준다.

float3 UnityObjectToWorldNormal(in float3 norm) 객체 공간이 노멀을 취해 월드 공간에서의 노멀 값으로 변환해준다.

빛을 계산하는데 유용하다.

float3 UnityWorldSpaceViewDir(in float3 worldPos) 월드 공간에서의 정점 위치를 취해 월드 공간에서의 뷰의 방향을 반환한다. 빛을 계산하는데 유용하다.

float3 UnityWorldSpaceLightDir(in float3 worldPos) 월드 공간에서의 정점 위치를 취해 공간에서의 빛의 방향을 반환한다. 빛을 계산하는데 유용하다.

unity_ObjectToWorld 객체 공간에서 월드공간으로 변환하는 행렬

unity_WorldToObject 위의 행열의 역행렬, 월드공간에서 객체 공간으로 변환하는 행렬

샘플) float4 vertexWorld = mul(unity_ObjectToWorld, v.vertex);

unity_WorldToCamer 월드 공간에서 카메라 공간으로 변환한다.

unity_CameraToWorld 위행열의 역행렬, 카메라 공간에서 월드 공간으로 변환한다.

float3 UnityViewToClipPos(in float3 pos) 뷰 공간에서 절단 공간으로 위치를 변환한다.

float4 UnityWorldToClipPos(in float pos) 위치를 월드 공간에서 절단 공간으로 변환

float4 UnityViewToClipPos(in float pos) 위치를 뷰 공간에서 절단 공간으로 변환

float4 UnityObjectToClipPos(in float pos) 정점 위치를 객체 공간에서 절단 공간으로 변환

밝기를 계산하는 방법

float brightness = cos(angle_of_incidence) // 입사각으로 구하는 밝기
float brightness = dot(normal,lightDir) // 노멀 벡터와 빛의 방향 벡터로 계산한 밝기
float3 pixelColor = brightness*lightColor*surfaceColor // 입사각으로 구하는 밝기

내적은 두 벡터의 각 성분끼리의 곱이라고 합니다.(스칼라곱이라고도 한다.)

빨간부분이 하나의 점이 되는데 점은 영어로 dot이고 그리고 이것은 내적인겁니다.

내적은 게임에서 복잡한 cosθ식을 좀더 가벼운 연산으로 바꿔서 사용하는 용도로 사용한다고 합니다.

길이가 1인 벡터는 단위벡터(unit vector)라고 하고 단윈벡터를 만드는 과정을 정규화(normalize)라고 합니다.