개발자의 삶

데이터 형식(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"
}