개발자의 삶

흐름 제어 - 코드 실행 순서를 결정하는 것

분기 - 제어 흐름을 여러 갈래로 나누는 것
         단, 프로그램은 한 번에 하나만 실행 가능

분기문1 : if

분기문2 : switch + break

int input = Convert.ToInt32(Console.ReadLine());

int score = (int)(Math.Truncate(input/10.0) * 10);
// 1의 자리 버림

string grade = "";

switch (score)
{
    case 90:
       grade = "A";
       break;
       
    case 80:
       grade = "B";
       break;
       
    case 70:
       grade = "C";
       break;
       
    case 60:
       grade = "D";
       break;
       
    default:
       grade = "F";
       break;
}

int input = Convert.ToInt32(Console.ReadLine());

int score = (int)(Math.Truncate(input/10.0) * 10);

string grade = score switch
{
    90 => "A",
    80 => "B",
    70 => "C",
    60 => "D",
    _ => "F"
};

반복문 1 : while
조건을 만족하는 동안 반복

반복문 2 : do while
코드 실행후, 조건을 평가하여 반복 수행

반복문 3 : for
조건을 만족하는 동안 반복(조건 변수 사용)

점프 : 흐름을 특정 위치로 단번에 이동
break, continue, goto, return, throw

break
반복문이나 switch문의 실행을 중단

continue
반복을 건너 뛰어 반복을 계속 수행

goto
지정한 레이블로 제어를 이동

패턴매칭
식이 특정패턴과 일치하는지를 검사

패턴매칭1 : 선언 패턴
주어진 식이 특정형식(int, string) 과 일치하는지를 평가

패턴매칭2 : 형식 패턴
선언 패턴과 거의 비슷하지만 변수를 선언하지 않는다.

패턴매칭3 : 상수 패턴
식이 특정 상수와 일치하는지를 검사

패턴매칭4 : 프로퍼티 패턴
식의 속성이나 필드가 패턴과 일치하는지를 검사

패턴매칭5 관계 패턴
관계 연사자를 이용하여 입력받은 식을 상수와 비교

패턴매칭6 :  논리패턴
복수의 패턴을 논리 연산자(and, or, not)로 조합

패턴매칭7 : 괄호패턴
괄호()로 패턴을 감쌈

패턴매칭8 : 위치 패턴
식의 결과를 분해하고, 분해된 값들이 내장된 복수의 패턴과 일치하는지 검사

패턴매칭9 : var 패턴
null을 포함한 모든 식의 패턴 매칭을 성공시키고, 그 식의 결과를 변수에 할당

패턴매칭10 : 무시 팬턴
var패턴처럼 모든 식과의 패턴 일치 검사를 성공
단, is식에서는 사용할 수 없고, switch식에서만 사용 가능

패턴매칭11 : 목록 패턴
배열이나 리스트가 패턴의 시퀀스가 일치하는지를 검사

using System;
using System.Collections.Generic;
using System.Diagnostics.Tracing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20240226
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //int a = 1;
            //while(a== 2)
            //{
            //    Console.WriteLine("true");
            //}Console.WriteLine("false");

            //1. 구구단 출력하기: 사용자로부터 숫자를 입력받아 해당 숫자의 구구단을 출력하는 프로그램을 작성하세요.
            //for (int i = 1; i <= 9; i++)
            //{
            //    for(int j = 1; j <= 9; j++)
            //    {
            //        Console.WriteLine($"{i} * {j} = {i * j}");
            //    }
            //}


            //2. 숫자 맞히기 게임: 컴퓨터가 1에서 100 사이의 무작위 숫자를 선택하고, 사용자가 그 숫자를 맞히는 게임을 만드세요.사용자가 입력한 숫자가 정답보다 크면 "더 작은 수를 입력하세요"를, 작으면 "더 큰 수를 입력하세요"를 출력하세요. 정답을 맞힐 때까지 반복합니다.
            //Random random = new Random(); //Random 클래스 인스턴스 생성
            //int rand = random.Next(1, 101);// 1부터 100까지 난수 생성
            //Console.Write("숫자를 입력하세요. >> ");
            //int num = int.Parse(Console.ReadLine());
            //Console.WriteLine("컴퓨터가 입력한 숫자는 {0}입니다.", rand);
            //if (rand == num)
            //{
            //    Console.WriteLine("정답");
            //}
            //else Console.WriteLine("오답");



            //3. 짝수와 홀수 합계: 1에서 100까지의 모든 짝수와 홀수의 합을 구하는 프로그램을 작성하세요.
            //int odd = 0;
            //int even = 0;
            //for (int i = 1; i <= 100; i++)
            //{
            //    if(i % 2 != 0)
            //    {
            //        odd += i;
            //    }else if(i % 2 == 0)
            //    {
            //        even += i;
            //    }

            //}
            //Console.WriteLine(odd);
            //Console.WriteLine(even);

            //4. 사용자가 입력한 수의 팩토리얼 계산: 사용자로부터 정수를 입력받고, 그 수의 팩토리얼을 계산하여 출력하는 프로그램을 작성하세요.
            //int a = Convert.ToInt32(Console.ReadLine());
            //int factorialA = 1;
            //for(int i = 1; i <= a; i++)
            //{
            //    factorialA *= i;
            //}
            //Console.WriteLine(factorialA);
            //5. 세 수 중 최댓값 찾기: 사용자로부터 세 개의 숫자를 입력받고, 그 중 가장 큰 숫자를 출력하는 프로그램을 작성하세요.
            //int a = Convert.ToInt32(Console.ReadLine());
            //int b = Convert.ToInt32(Console.ReadLine());
            //int c = Convert.ToInt32(Console.ReadLine());
            //int maxNum = a;
            
            //if( b > maxNum)
            //{
            //    maxNum = b;
            //}
            //if( c > maxNum)
            //{
            //    maxNum = c;
            //}
            //Console.WriteLine("입력된 숫자중 가장 큰 수는 {0} 입니다. ", maxNum);
        }
    }
}

Shader "Custom/Triplanar"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Top("Top", 2D) = "white" {}
        _Side("Side", 2D) = "white" {}
        _Front("Front", 2D) = "white" {}

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

        CGPROGRAM
        #pragma surface surf Lambert
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _Top;
        sampler2D _Front;
        sampler2D _Side;

        struct Input
        {
            float2 uv_MainTex;
            float3 worldPos;
            float3 worldNormal;
            INTERNAL_DATA
        };

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

            float2 topUV = float2(IN.worldPos.x, IN.worldPos.z);
            float2 sideUV = float2(IN.worldPos.z, IN.worldPos.y);
            float2 frontUV = float2(IN.worldPos.x, IN.worldPos.y);




            float4 topColor = tex2D(_Top, topUV); // green = 1

            float4 sideColor = tex2D(_Side, sideUV); // red = 1

            float4 frontColor = tex2D(_Front, frontUV); // blue = 1

            //float3 n = WorldNormalVector(IN, o.Normal); //해당 면의 normal 벡터 => 값이 1이 된다.
            
            //혼합 lerp
            
            //float3 e = lerp(0, 1, topColor.g);
            //o.Emission = topColor.rgb;
            //o.Albedo = sideColor.rgb;
            //o.Emission = n.rgb;
            o.Albedo = lerp(topColor, frontColor,abs(IN.worldNormal.z));
            //위쪽 면의 색상과 앞면의 색상을 표면의 기울기에 따라 가중 평균화하여 새로운 색상을 생성
            //기울기가 높을수록 앞면의 색상이 더 많이 나타나며, 기울기가 낮을수록 위쪽 면의 색상이 더 많이 나타낸다.
            o.Albedo = lerp(o.Albedo, sideColor, abs(IN.worldNormal.x));
            o.Alpha = 1;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

그림과 같이 각 면이 해당하는 벡터를 확인한 후 색상을 집어 넣어야 한다.

Shader "Custom/Triplanar"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Top("Top", 2D) = "white" {}
        _Side("Side", 2D) = "white" {}
        _Front("Front", 2D) = "white" {}

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

        CGPROGRAM
        #pragma surface surf Lambert
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _Top;
        sampler2D _Front;
        sampler2D _Side;

        struct Input
        {
            float2 uv_MainTex;
            float3 worldPos;
            float3 worldNormal;
            INTERNAL_DATA
        };

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

            float2 topUV = float2(IN.worldPos.x, IN.worldPos.z);
            float2 sideUV = float2(IN.worldPos.z, IN.worldPos.y);
            float2 frontUV = float2(IN.worldPos.x, IN.worldPos.y);




            float4 topColor = tex2D(_Top, topUV); // green = 1

            float4 sideColor = tex2D(_Side, sideUV); // red = 1

            float4 frontColor = tex2D(_Front, frontUV); // blue = 1

            float3 n = WorldNormalVector(IN, o.Normal); //해당 면의 normal 벡터 => 값이 1이 된다.
            
            //혼합 lerp
            
            //float3 e = lerp(0, 1, topColor.g);
            //e = lerp (e, topColor.r, sideColor);
            //e = lerp (e, topColor.b, frontColor);
            //o.Emission = topColor.rgb;
            //o.Albedo = sideColor.rgb;
            o.Emission = n.rgb;
            //o.Albedo = lerp(topColor, frontColor,abs(IN.worldNormal.z));
            //위쪽 면의 색상과 앞면의 색상을 표면의 기울기에 따라 가중 평균화하여 새로운 색상을 생성
            //기울기가 높을수록 앞면의 색상이 더 많이 나타나며, 기울기가 낮을수록 위쪽 면의 색상이 더 많이 나타낸다.
            //o.Albedo = lerp(o.Albedo, sideColor, abs(IN.worldNormal.x));
            o.Alpha = 1;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

https://docs.unity3d.com/ScriptReference/Vector3.Lerp.html

연산자란?

컴파일러에게 데이터 가공을 지시하는 신호

종류 : 산술 / 관계 / 논리 / 비트 /할당 / 기타 ...

증감 연산자 전위, 후위 연산자

int a = 10;
Console.WriteLine(++a);
// a = 11
int b = 10;
Console.WriteLine(b++);
// b = 10
Console.WriteLine(b++);
// b = 11

전위 연산자는 보기와 같이 기존에 정해진 값에서 더한 후 그 값을 출력

후위 연산자는 출력된 후 더하므로

다음 출력때 더해진 값을 출력

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20240223
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //사용자로부터 두 개의 숫자를 입력 받아 덧셈, 뺄셈, 곱셈, 나눗셈 연산을 수행하고 결과를 출력하는 프로그램을 작성하세요.
            //Console.WriteLine(10 + 5);
            //Console.WriteLine(10 - 5);
            //Console.WriteLine(10 * 5);
            //Console.WriteLine(10 / 5);


            //반지름을 입력 받아 원의 넓이를 계산하여 출력하는 프로그램을 작성하세요. (힌트: 원의 넓이 공식 - π * r * r)
            //int r = 5;
            //float circle = r * r * 3.14f;
            //Console.WriteLine(circle);

            //비교 연산자:
            //사용자로부터 두 개의 숫자를 입력 받아 두 숫자가 같은지 여부를 판단하여 결과를 출력하는 프로그램을 작성하세요.
            //Console.WriteLine(10 == 5);

            //사용자로부터 세 개의 숫자를 입력 받아 가장 큰 숫자를 출력하는 프로그램을 작성하세요.
            //int num1 = Convert.ToInt32(Console.ReadLine());
            //int num2 = Convert.ToInt32(Console.ReadLine());
            //int num3 = Convert.ToInt32(Console.ReadLine());
            //int maxNum = Math.Max(num1, Math.Max(num2, num3));
            //Console.WriteLine(maxNum);


            //논리 연산자:
            //사용자로부터 입력받은 숫자가 짝수인지 여부를 판단하여 결과를 출력하는 프로그램을 작성하세요.
            //int num = int.Parse(Console.ReadLine());
            //bool isEven = num % 2 == 0;
            //Console.WriteLine(isEven);


            //사용자로부터 입력받은 숫자가 3의 배수인지 그리고 5의 배수인지를 동시에 판단하여 결과를 출력하는 프로그램을 작성하세요.
            //int num = int.Parse(Console.ReadLine());
            //if(num % 15 == 0)
            //{
            //    Console.WriteLine("3과 5배 공배수");
            //}
            //else if(num % 3 == 0)
            //{
            //    Console.WriteLine("3의 배수입니다.");
            //}else if(num % 5 == 0){
            //    Console.WriteLine("5의 배수");
            //}
            //else {
            //    Console.WriteLine("다른 수");
            //}

            //대입 연산자:
            //사용자로부터 숫자를 입력 받아 그 숫자를 10배로 증가시킨 후 결과를 출력하는 프로그램을 작성하세요.
            //int number = Convert.ToInt32(Console.ReadLine());
            //int result = number * 10;
            //Console.WriteLine("Result: " + result);
            //두 변수의 값을 교환하는 프로그램을 작성하세요. (예: 변수 a에 5, 변수 b에 10이 있다면 a에는 10, b에는 5가 저장되어야 함)
            //int a = 10;
            //int b = 20;
            //int temp = a;
            //a = b;
            //b = temp;
            //Console.Write("a는 {0} b는 {1}", a, b);

        }

    }
}

데이터 형식(Data Types):

데이터의 '유형'과 '크기'를 지정

1. 기본 데이터 형식 (값 형식)

- 정수형식 (int,byte ..etc)

- 부동 소수형식 (float, double, demical)

2. 복합 데이터 형식

- 클래스

- 구조체(값 형식)

- 인터페이스

스택(Stack):

데이터를 쌓아 올리는 구조의 메모리

쌓인 순서의 역순으로 필요 없는 데이터를 자동으로 제거(자동메모리) => LIFO(Last In First Out)

힙(Heap):

자유롭게 데이터를 저장할 수 있는 메모리

별명 : 자유 저장소

값 형식(Value Type):

메모리에 값을 담는 형식

스택에 할당

기본 데이터 형식과 구조체가 여기에 해당됨

참조형식(Reference Type):

메모리에 다른 변수의 "주소를 담는" 데이터 형식

힙에 할당

기본 데이터 형식(Primitive Types)

수 형식(정수 형식, 부동 소수점 형식)

논리 형식

문자열 형식

object 형식

복합데이터 형식 : 기본 데이터 형식을 바탕으로 만들어짐

박싱 : 값 형식을 object형식에 담아 힙에 올리기
언박싱 : 힙에 올라가 있는 데이터를 object에서 꺼내 값 형식으로 옮기기

변수 : 변경이 가능한 수
상수 : 항상 최초의 상태를 유지하는 수 -> 변경하려는 시도시 컴파일 에러

열거형식 : 하나의 이름 아래 묶인 상수들의 집합

=>  enum키워드 사용
상수 선언시 ex) enum dia{yes} -> dia.yes;

var키워드 - 컴파일러가 자동으로 형식을 추론
ex) var a = 3; // a는 int 형식
주의 : "지역변수 안"에서만 사용가능(메소드 안에서만 ) + 클래스, 구조체 사용불가

using System;
using System.Collections.Generic;
using System.Data.SqlTypes;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _20240222
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //변수(Variables)에 대한 예제 문제:
            //1-1. 특정 프로그램에서 사용자의 이름을 입력받아 변수에 저장하고, 그 이름을 환영하는 메시지를 출력하는 프로그램을 작성하세요.
            //string a = "예준";
            //Console.WriteLine($"어서오세요 {a}");
            //Console.WriteLine("어서오세요 {0}", a);

            //2-2. 특정 도시의 현재 온도를 나타내는 변수를 만들고, 이 변수의 값을 5도 증가시킨 후 새로운 온도를 출력하는 프로그램을 작성하세요.
            //int temp = 24;
            //int now = temp + 5;
            //Console.WriteLine($"현재 온도는 {now}도 입니다");

            //3-3. 사용자로부터 두 개의 숫자를 입력받아 변수에 저장하고, 이 두 숫자를 더한 결과를 출력하는 프로그램을 작성하세요.
            //int a = 10;
            //int b = 20;
            //Console.WriteLine(a + b);

            //상수(Constants)에 대한 예제 문제:
            //2-1. 원주율을 상수로 선언하여 반지름이 5인 원의 넓이를 계산하여 출력하는 프로그램을 작성하세요.
            //float pi = 3.14f;
            //int r = 5;  // => float 과 int 의 곱이 된다.
            //float size = pi * pi * r;
            //Console.WriteLine(size);

            //2-2. 세금 비율을 0.1로 상수로 선언하고, 사용자로부터 어떤 상품의 가격을 입력받아 세금을 계산하여 총 가격을 출력하는 프로그램을 작성하세요.
            //float rate = 0.1f;
            //float price = 50.6f;
            //float total = rate * price;
            //Console.WriteLine(total); //=> 5.06

            //2-3. 1년에는 몇 개의 달이 있는지를 상수로 선언하고, 이 값을 사용하여 1년이 몇 개의 주가 있는지를 출력하는 프로그램을 작성하세요.
            //int CountOfMonth = 12;
            //int day = 365;
            //float CountOfWeek = day / CountOfMonth;
            //Console.WriteLine(CountOfWeek);
            // => 인트형끼리 나누면 소수점 자리가 Truncate을 하지 않아도 된다.


            //float CountOfMonth = 12f;
            //float day = 365f;
            ////float CountOfWeek = Math.Truncate(day / CountOfMonth); ==> 오류
            //float CountOfWeek = day / CountOfMonth;
            //Console.WriteLine(Math.Truncate(CountOfWeek)); // 30


        }
    }
}

3D 오브젝트 2pass로 테두리 생성

Shader "Custom/CubeMap"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _CubeMap ("CubeMap", CUBE) = ""{}
    }
    SubShader
    {   
        Tags { "RenderType"="Opaque" }
        //1Pass
        Cull Front
        CGPROGRAM
        #pragma surface surf _NoLight vertex:vert
        #pragma target 3.0

        sampler2D _MainTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void vert(inout appdata_full v){
            v.vertex.xyz = v.vertex.xyz + v.normal.xyz * 0.01;
            }

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

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

        //2Pass
        CGPROGRAM
        #pragma surface surf Lambert
        #pragma target 3.0

        sampler2D _MainTex;
        samplerCUBE _CubeMap;
        sampler2D _NormalMap;

        struct Input
        {
            float2 uv_MainTex;
            float3 worldRefl; //float2의 uv가아닌 반사벡터를 받는다. => 예약어
            float2 uv_NormalMap;
            INTERNAL_DATA
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            //텍스쳐
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            float3 n = UnpackNormal(tex2D(_NormalMap, IN.uv_MainTex));
            o.Normal = n;


            float3 ref = WorldReflectionVector(IN, o.Normal);
            float4 d = texCUBE(_CubeMap, ref);
            o.Albedo = c.rgb * 0.5;
            o.Emission = d.rgb * 0.5 ;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

_Cube("Cubemap", Cube) = "" {}

// 평소와 다르게 큰따옴표 안을 비워주고 프로퍼티를 생성

그리고 Input 구조체안에 float2의 UV가 아닌 반사 벡터를 받아 온다.

CubeMap에서 알베도를 0으로 선택

INTERNAL_DATA

https://docs.unity3d.com/kr/2021.3/Manual/SL-SurfaceShaders.html

1번.

Diffuse Warping + NormalMap + Texture

Shader "Custom/WarpedDiffuse"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _RampTex ("Ramp Texture", 2D) = "white" {}
        _NormalMap("Normal Map", 2D) = "bump" {}
        _OutLine("OutLine", Range(0,1)) = 0.2
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf _Warped
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _RampTex;
        sampler2D _NormalMap;
        float _OutLine;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            float4 d = tex2D(_NormalMap, IN.uv_NormalMap);
            //float3 normal = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = UnpackNormal(d);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        float4 Lighting_Warped(SurfaceOutput s, float3 lightDir, float3 viewDir, float atten)
        {
            float4 final;
            float ndotl = dot(s.Normal, lightDir);

            float rim = dot(s.Normal, viewDir);
            if(rim >= _OutLine) rim = 1;
            else rim = 0;

            fixed4 ramp = tex2D(_RampTex, float2(ndotl, 0.5));
            
            final.rgb = s.Albedo.rgb * ramp.    rgb * rim;
            final.a = s.Alpha;

            return final;
        }
        ENDCG

    }
    FallBack "Diffuse"
}

2.

1번  + 2Pass 외곽선 + RampTex 적용

Shader "Custom/WarpedDiffuse"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _RampTex ("Ramp Texture", 2D) = "white" {}
        _NormalMap("Normal Map", 2D) = "bump" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf _Warped
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _RampTex;
        sampler2D _NormalMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            o.Albedo = c.rgb;
            float3 normal = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = normal;
        }

        float4 Lighting_Warped(SurfaceOutput s, float3 lightDir, float atten)
        {
            float ndotl = dot(s.Normal, lightDir);
            float2 uv = float2(ndotl, 0.5);
            float4 c = tex2D(_RampTex, uv);
            return c;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

3.

Fresnel 외곽선 + RampTex

Shader "Custom/WarpedDiffuse"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _RampTex ("Ramp Texture", 2D) = "white" {}
        _NormalMap("Normal Map", 2D) = "bump" {}
        _OutLine("OutLine", Range(0,1)) = 0.2
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf _Warped
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _RampTex;
        sampler2D _NormalMap;
        float _OutLine;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            float4 d = tex2D(_NormalMap, IN.uv_NormalMap);
            //float3 normal = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
            o.Normal = UnpackNormal(d);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        float4 Lighting_Warped(SurfaceOutput s, float3 lightDir, float3 viewDir, float atten)
        {
            float4 final;
            float ndotl = dot(s.Normal, lightDir);

            float rim = dot(s.Normal, viewDir);
            if(rim >= _OutLine) rim = 1;
            else rim = 0;

            fixed4 ramp = tex2D(_RampTex, float2(ndotl, 0.5));
            
            final.rgb = s.Albedo.rgb * ramp.    rgb * rim;
            final.a = s.Alpha;

            return final;
        }
        ENDCG

    }
    FallBack "Diffuse"
}

4번.

2pass + 커스텀 스페큘러

Shader "Custom/WarpedDiffuse"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _RampTex ("Ramp Texture", 2D) = "white" {}
        _NormalMap("Normal Map", 2D) = "bump" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        Cull Front
        CGPROGRAM
        #pragma surface surf _NoLight vertex:vert
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _RampTex;
        sampler2D _NormalMap;

        struct Input
        {
            float4 color : COLOR;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
        }

        void vert(inout appdata_full v){
            v.vertex.xyz  = v.vertex.xyz + v.normal.xyz * 0.01;
            }

        float4 Lighting_NoLight(SurfaceOutput s, float3 lightDir, float3 viewDir, float atten)
        {
            return float4(0,0,0,1);
        }
        ENDCG
        Cull Back


        CGPROGRAM
        #pragma surface surf _Warped
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _RampTex;
        sampler2D _NormalMap;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
            float4 color : COLOR;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            float4 d = tex2D(_NormalMap, IN.uv_NormalMap);
            o.Normal = UnpackNormal(d);
            o.Albedo = c.rgb;
            o.Alpha = c.a;
        }

        float4 Lighting_Warped(SurfaceOutput s, float3 lightDir, float3 viewDir, float atten)
        {
            float4 final;

            //half-lambert
            float ndotl = dot(s.Normal, lightDir) * 0.5 + 0.5;

            //spec
            float3 h = normalize(lightDir + viewDir);
            float spec = saturate(dot(s.Normal,h));
            //spec => pow

            //Ramp
            float4 ramp = tex2D(_RampTex,float2(ndotl, 0.5));

            //final
            final.rgb = s.Albedo.rgb * (ramp.rgb + 0.5) * spec;
            final.a = s.Alpha;



            return final;
        }
        ENDCG

     }
    FallBack "Diffuse"
}

Shader "Custom/phong2"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _SpecColor ("Specular Color", Color) = (1,1,1,1)
        _NormalMap ("Normal Map", 2D) = "bump" {}
        _GlossTex ("Gloss Map", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf _Phong noambient
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _NormalMap;
        sampler2D _GlossTex;

        struct Input
        {
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            float3 n = UnpackNormal(tex2D(_NormalMap, IN.uv_MainTex));
            float4 g = tex2D(_GlossTex, IN.uv_MainTex);
            o.Normal = n;
            o.Albedo = c.rgb;
            o.Gloss = g.a;
            o.Alpha = c.a;
        }

        float4 Lighting_Phong(SurfaceOutput s, float3 lightDir, float3 viewDir, float atten)
        {
            float4 final;

            //diffuse
            //lambert : N · L
            float3 diffuseColor;
            float ndotl = saturate(dot(s.Normal, lightDir));
            //벡터 * 색상 * 감쇠 * 광원컬러
            diffuseColor = ndotl * s.Albedo * atten * _LightColor0.rgb;

            //spec
            float3 specularColor;
            //1. 하프 단위 벡터 구하기 lightDir + viewDir 
            float3 h = normalize(lightDir + viewDir);
            //2. 노멀벡터와 내적 
            float spec = saturate(dot(s.Normal, h));
            //벡터 * 색상 * 글로스 * 색상
            specularColor = pow(spec, 100) * s.Gloss * _SpecColor.rgb;


            //rim 
            float3 rimColor;
            float rim = abs(dot(s.Normal, viewDir));
            float inverseRim = 1-rim;
            rimColor = pow(inverseRim, 3);
            //fake specular 
            float3 fakeSpec = rimColor * s.Gloss * float3(0.1, 0.1, 0.1);
            
            final.rgb = specularColor + diffuseColor + fakeSpec;
            final.a = s.Alpha;

            return final;
        }

        ENDCG
    }
    FallBack "Diffuse"
}

차례대로 Standard, CustomLambert, HalfLambert

1. Standard

Shader "Custom/lambert"
{
    Properties
    {
        _MainTex("Main Texture", 2D) = "white"{}
        _NormalMap("NormalMap", 2D) = "bump" {}
        _Color("Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0
        sampler2D _MainTex;
        sampler2D _NormalMap;     
        float4 _Color;
        struct Input
        {
            float4 color : COLOR;
            float2 uv_MainTex;
            float2 uv_NormalMap;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            float4 d = tex2D(_NormalMap, IN.uv_NormalMap);
            o.Normal = UnpackNormal (d);
            o.Albedo = c.rgb * _Color;
            o.Alpha = c.a;
        }
        // 빛을 만든다
       
        ENDCG
    }
    FallBack "Diffuse"
}

2. CustomLambert

Shader "Custom/customLambert"
{
    Properties
    {
        _MainTex("Main Texture", 2D) = "white"{}
        _NormalMap("NormalMap", 2D) = "bump" {}
        _Color("Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf _MyLambert
        #pragma target 3.0
        sampler2D _MainTex;
        sampler2D _NormalMap;     
        float4 _Color;
        struct Input
        {
            float4 color : COLOR;
            float2 uv_MainTex;
            float2 uv_NormalMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            float4 d = tex2D(_NormalMap, IN.uv_NormalMap);
            o.Normal = UnpackNormal (d);
            o.Albedo = c.rgb * _Color;
            o.Alpha = c.a;
        }
        // 빛을 만든다
        float4 Lighting_MyLambert(SurfaceOutput s, float3 lightDir, float atten)
        {
            float4 final;
            float ndot1 = dot(s.Normal, lightDir);
            final.rgb = ndot1 * s.Albedo.rgb;
            final.a = s.Alpha;
            return final;
            }
        ENDCG
    }
    FallBack "Diffuse"
}

2-2. CustomLambert

Shader "Custom/customLambert"
{
    Properties
    {
        _NormalMap("Normal Map",2D) = "bump"{}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf _MyLambert noambient;
        #pragma target 3.0
        sampler2D _NormalMap;     
        struct Input
        {
            float4 color : COLOR;
            float2 uv_NormalMap;
        };
        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_NormalMap, IN.uv_NormalMap);
            o.Normal = UnpackNormal (c);
            o.Albedo = 1;
            
        }

        float4 Lighting_MyLambert(SurfaceOutput s, float3 lightDir, float atten)
        {
            float4 final;
            //return float4(1,0,0,1);
            //노멀벡터와 조명벡터를 내적해라
            float ndot1 = dot(s.Normal, lightDir);
            final = saturate(ndot1);
            return final;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

3. HalfLambert

Shader "Custom/customLambert2"
{
    Properties
    {
        _MainTex("Main Texture", 2D) = "white"{}
        _NormalMap("NormalMap", 2D) = "bump" {}
        _Color("Color", Color) = (1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf _MyLambert
        #pragma target 3.0
        sampler2D _MainTex;
        sampler2D _NormalMap;     
        float4 _Color;
        struct Input
        {
            float4 color : COLOR;
            float2 uv_MainTex;
            float2 uv_NormalMap;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            float4 d = tex2D(_NormalMap, IN.uv_NormalMap);
            o.Normal = UnpackNormal (d);
            o.Albedo = c.rgb * _Color;
            o.Alpha = c.a;
        }
        // 빛을 만든다
        float4 Lighting_MyLambert(SurfaceOutput s, float3 lightDir, float atten)
        {
            float4 final;
            float ndot1 = dot(s.Normal, lightDir)* 0.5 + 0.5;
            final = pow(ndot1, 3);
            final.rgb = ndot1 * s.Albedo.rgb * _LightColor0.rgb * atten;
            final.a = s.Alpha;
            return final;
            }
        ENDCG
    }
    FallBack "Diffuse"
}

CustomLambert의 기본형

1. #pragma surface surf _MyLambert

2. void surf (Input IN, inout SurfaceOutput o)

3. float4 Lighting_MyLambert(SurfaceOutput s, float3 lightDir, float atten)
 {
  ;
     return float4(1, 0, 0 , 1);

 }

우선 이 3가지로 스탠다드를 바꿔주고 메서드를 만들어준다.

이때 매개변수는 변경하거나 수정할 수 없으며 주어진 대로 사용해야 한다.

float3 lightDir
조명 방향의 벡터
단, 조명을 편하게 사용하기 위해 뒤집혀지고 길이가 1인 단위 벡터 상태

float atten(uation) - 감쇠
그림자를 받거나 거리가 멀어지면 점점 조명이 흐려지는 라이트의 거리별 현상

dot : 노멀 벡터와 라이트 벡터를 내적 연산해주는 함수

우리는 o.Normal에 값을 넣지 않았지만 s.Normal의 값을 가져올 수 있다.

lightDir은 vertex에서 바라보는 조명의 방향을 뒤집은 조명 벡터이므로 두 벡터를 단순히 내적하면 cos값이 나온다.

나중에 ambient light 또는 추가라이트를 비출 때 이 음수는 문제를 일으킬수 있는데

이(0아래는 전부 0으로 잘라주는)를 해결해주는 함수 saturate, max가 있다.

이 함수들을 사용하면 빨간선처럼 0보다 작은수는 0으로 지정해준다.

HalfLambert

* 0.5 + 0.5는 마법의 숫자이다.

이 공식은 -1 ~ 1까지의 숫자를 0에서 1까지의 범위로 만들어준다.

그 결과 cos라인을 끌어 올려주어 부드러운 결과 값이 나온다.

조명의 색상 or 감쇠를 이용할 수 있다.

ex) final.rgb = ndotl * s.Albedo * _LightColor0.rgb * atten;

https://docs.unity3d.com/kr/2021.3/Manual/SL-UnityShaderVariables.html

이에 따라 조명의 색깔을 변경하고 거리에 따른 그림자를 조절할 수 있다.

https://docs.unity3d.com/kr/530/Manual/StandardShaderMaterialParameterAlbedoColor.html

Shader "Custom/fire"
{
    Properties
    {
        _MainTex ("Main Texture", 2D) = "white"{}
        _MainTex2 ("Main Texture2", 2D) = "white"{}
        _Speed("Speed", Range(0,10.0)) = 1
        _BrightNess("BrightNess", Range(0,1)) = 1
        _Color("Color",Color) = (1,1,1,1)
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent"}

        CGPROGRAM
        #pragma surface surf Standard alpha:fade
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _MainTex2;
        float _Speed;
        float _BrightNess;
        float _Color;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_MainTex2;
           
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            //데이터 
            float2 d_uv = IN.uv_MainTex2;
            d_uv.y -= _Time.y;
           
            float4 d = tex2D(_MainTex2, d_uv * _Speed);

            //d.rgb
            //d.r => 0 

            //체크 
            float2 c_uv = IN.uv_MainTex;
            float4 c = tex2D(_MainTex, c_uv + d); 

            //체크를 보여주고 있음 
            o.Emission = c.rgb * _BrightNess;
            o.Alpha = c.a ;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

Shader "Custom/vertexcolor"
{
    Properties
    {
        _MainTex("Main Texture", 2D) = "white"{}
        _MainTex2("Main Texture2", 2D) = "white"{}
        _MainTex3("Main Texture3", 2D) = "white"{}
        _MainTex4("Main Texture4", 2D) = "white"{}
        
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
     

        CGPROGRAM
      
        #pragma surface surf Standard fullforwardshadows

        #pragma target 3.0

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


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


        };

       

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
           float4 c =tex2D(_MainTex, IN.uv_MainTex);
           //o.Emission = c.rgb + IN.color.rgb;

           IN.uv_MainTex2 -= _Time.y * 0.2;
           //float2 d_uv2 = IN.uv_MainTex2;
            //d_uv2.y -= _Time.y;
            float4 d = tex2D(_MainTex2,IN.uv_MainTex2);
           o.Emission = lerp(c.r, d.rgb, IN.color.r ); // 보이지 않는 곳을 0 보이는 곳을 1이라고 생각
           

           float4 e = tex2D(_MainTex3, IN.uv_MainTex3);
           o.Emission = lerp(o.Emission, e.rgb, IN.color.g);

           float4 f = tex2D(_MainTex4, IN.uv_MainTex4);
           o.Emission = lerp(o.Emission, f.rgb, IN.color.b);
           
        }
        ENDCG
    }
    FallBack "Diffuse"
}

Shader "Custom/rock"
{
    Properties
    {
        _MainTex ("Main Texture", 2D) = "white"{}
        _MainTex2 ("Main Texture2", 2D) = "white"{}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _MainTex2;

        struct Input
        {
            float4 color : COLOR; //버텍스 컬러 
            float2 uv_MainTex;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            //이끼 
            float4 d = tex2D(_MainTex2, IN.uv_MainTex);
            //돌맹이 
            float4 c = tex2D(_MainTex, IN.uv_MainTex);
            
            //이끼를 버텍스 컬러 R 부분에 출력하자 
            o.Albedo = lerp(c.rgb, d.rgb, IN.color.r);
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

https://docs.unity3d.com/kr/530/Manual/StandardShaderMaterialParameterMetallic.html

https://docs.unity3d.com/kr/2022.1/Manual/StandardShaderMaterialParameterSmoothness.html

https://docs.unity3d.com/Manual/StandardShaderMaterialParameterNormalMap.html

Shader "Custom/Metallic"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
        _NormalMap ("NormalMap", 2D) = "bump"{}
        _NormalStength("Normal Stength", Range(0.1, 2)) = 0
        _Occlusion("Occlusion", 2D) = "white"{}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _NormalMap;
        sampler2D _Occlusion;
        float _NormalStength;

        struct Input
        {
            float2 uv_MainTex;
            float2 uv_NormalMap;
        };

        half _Glossiness;
        half _Metallic;

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

            float4 n = tex2D(_NormalMap, IN.uv_NormalMap);
            float3 normal = UnpackNormal(n);
            fixed4 occlusion = tex2D(_Occlusion, IN.uv_MainTex);

            o.Occlusion = occlusion;
            o.Metallic = _Metallic;
            o.Smoothness = _Glossiness;

            o.Normal = float3(normal.x * _NormalStength , normal.y * _NormalStength , normal.z);

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

Shader "Custom/rockGolem2"
{
    Properties
    {
        _MainTex("MainTex",2D) = "white" {}
        _MainTex2("Left Hand",2D) = "white" {}
        _MainTex3("Right Hand",2D) = "white" {}
        _NormalMap ("NormalMap", 2D) = "bump"{}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
        _Occlusion ("Occlusion", 2D) = "white"{}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
       
        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _MainTex2;
        sampler2D _MainTex3;
        sampler2D _NormalMap;
        half _Glossiness;
        half _Metallic;
        sampler2D _Occlusion;



        struct Input
        {
            float2 uv_MainTex;
            float2 uv_MainTex2;
            float2 uv_MainTex3;
            float4 color : COLOR;
            float2 uv_NormalMap;
        };
    
        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            //fixed4 c = tex2D(_MainTex, IN.uv_MainTex);
            //o.Albedo = IN.color.rgb;
            //o.Alpha = c.a;
            IN.uv_MainTex2.y += _Time.y * 0.2;
            IN.uv_MainTex3.y += _Time.y * 0.2;
            fixed4 body = tex2D (_MainTex, IN.uv_MainTex);
            fixed4 lHand = tex2D (_MainTex2, IN.uv_MainTex2);
            fixed4 rHand = tex2D (_MainTex3, IN.uv_MainTex3);


            //float2 d_uv2 = IN.uv_MainTex2;
            //d_uv2.y -= _Time.y;




            //o.Albedo = lerp(0, body, IN.color.r);
            o.Albedo = lerp(body, lHand, IN.color.r);
            o.Albedo = lerp(o.Albedo, rHand, IN.color.b);

            float4 n = tex2D(_NormalMap, IN.uv_NormalMap);
            float3 normal = UnpackNormal(n);
            o.Metallic = _Metallic;
            o.Smoothness = _Glossiness;
            o.Normal = normal;
            o.Occlusion = tex2D(_Occlusion, IN.uv_MainTex);


        }
        ENDCG
    }
    FallBack "Diffuse"
}