게임 그래픽 프로그래밍 문제 메모

문제 1

 

Shader "Custom/fire"
{
    Properties
    {
        _MainTex("Main Texture", 2D) = "white" {}
        _MainTex2("Main Texture2", 2D) = "white" {}
        _CrumpleIntensity("Crumple Intensity", Range(0.0, 1.0)) = 0.5 // 구겨지는 정도 조절
        _FlowSpeed("Flow Speed", Float) = 1.0 // 흐르는 속도 조절
    }

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

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

            sampler2D _MainTex;
            sampler2D _MainTex2;
            float _CrumpleIntensity;
            float _FlowSpeed;

            struct Input
            {
                float2 uv_MainTex;
                float2 uv_MainTex2;
            };

            void surf(Input IN, inout SurfaceOutputStandard o)
            {
                // 구겨지는 정도와 흐르는 속도 조절
                float2 uv = IN.uv_MainTex2;
                float4 d = tex2D(_MainTex2, float2(uv.x, uv.y - _Time.y * _FlowSpeed));
                float4 c = tex2D(_MainTex, IN.uv_MainTex + d.r * _CrumpleIntensity);

                // 이미지를 어둡게 만들어 구겨지는 정도를 약화시킴
                c.rgb *= _CrumpleIntensity; // 구겨지는 정도에 따라 색상의 밝기 조절

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

 

+++

 

문제 2

 

Shader "Custom/skel"
{
    Properties
    {
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _RedTex("Red Texture", 2D) = "white" {}
        _GreenTex("Green Texture", 2D) = "white" {}
        _BlueTex("Blue Texture", 2D) = "white" {}
    }
        SubShader
    {
        Tags { "RenderType" = "Opaque" }

        CGPROGRAM
        #pragma surface surf Standard
        #pragma target 3.0

        sampler2D _MainTex;
        sampler2D _RedTex;
        sampler2D _GreenTex;
        sampler2D _BlueTex;

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

        void surf(Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D(_MainTex, IN.uv_MainTex); // 원본 텍스처 샘플링

            // 각 색상 채널에 해당하는 텍스처 샘플링
            fixed4 redTexColor = tex2D(_RedTex, IN.uv_MainTex);
            fixed4 greenTexColor = tex2D(_GreenTex, IN.uv_MainTex);
            fixed4 blueTexColor = tex2D(_BlueTex, IN.uv_MainTex);

            fixed4 colorOverlay = fixed4(0, 0, 0, 0); // 오버레이 색상 초기화

            // 색상 채널별로 텍스처 적용
            if (IN.color.r > 0.5) {
                colorOverlay += redTexColor * IN.color.r; // R 채널에 따른 빨간색 텍스처 적용
            }
            if (IN.color.g > 0.5) {
                colorOverlay += greenTexColor * IN.color.g; // G 채널에 따른 녹색 텍스처 적용
            }
            if (IN.color.b > 0.5) {
                colorOverlay += blueTexColor * IN.color.b; // B 채널에 따른 파란색 텍스처 적용
            }

            // 최종 색상 적용을 위한 계산
            fixed maxChannel = max(max(IN.color.r, IN.color.g), IN.color.b);
            if (maxChannel > 0.5) { // 적어도 하나의 채널이 활성화 되어 있을 경우
                o.Albedo = colorOverlay.rgb;
            }
 	else {
  		o.Albedo = c.rgb; // 아니면 원본 텍스처 사용
		}

	o.Alpha = 1.0;
	}
	ENDCG
    }
    FallBack "Diffuse"
}

 

+++

 

문제 3

Shader "Custom/Holo"
{
    Properties
    {
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _Color("Color", Color) = (1,1,1,1)
        _Pow("Power", Range(1, 10)) = 1
        _Speed("Speed", Range(1, 10)) = 1
            _LineSpacing("Line Spacing", Range(1, 10)) = 3
    }
        SubShader
        {
            Tags { "RenderType" = "Transparent" "Queue" = "Transparent"}

            // 첫 번째 패스: 깊이 정보만 쓰기
            
                ZWrite On
                ColorMask 0

                CGPROGRAM
                #pragma surface surf _NoLit nolight keepalpha noambient noforwardadd nolightmap novertexlights noshadow
             struct Input
        {
            float2 color:COLOR;
        };
                  void surf(Input IN, inout SurfaceOutput o)
        {
        }
        float4 Lighting_NoLit(SurfaceOutput s, float3 lightDir, float atten)    //! 커스텀 라이트 함수를 만들어 아무런 연산을 하지 않습니다.
        {
            return 0.0f;
        }
                ENDCG
            

            // 두 번째 패스: 실제 랜더링
            ZWrite Off
            CGPROGRAM
            #pragma surface surf Lambert alpha:fade
            #pragma target 3.0

            sampler2D _MainTex;
            float4 _Color;
            float _Pow;
            float _Speed;
            float _LineSpacing;

            struct Input
            {
                float2 uv_MainTex;
                float3 viewDir;
                float3 worldPos;
            };

            void surf(Input IN, inout SurfaceOutput o)
            {
                o.Emission = _Color.rgb;
                float holo = pow(frac(IN.worldPos.g * _LineSpacing - _Time.y * _Speed), 30);// _Speed를 적용
                float ndotv = dot(o.Normal, IN.viewDir);
                float rim = pow(1 - ndotv, _Pow);
                o.Alpha = rim + holo;
            }
            ENDCG
        }
            FallBack "Diffuse"
}

 

+++

 

문제4

 

Shader "Custom/Outline2Pass"
{
    Properties
    {
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _OutlineColor("Outline Color", Color) = (0,0,0,1) // 외곽선 색상
         _OutlineWidth("Outline Width", Range(0.001, 0.1)) = 0.01        // 외곽선 두께
    }
        SubShader
        {
            Tags { "RenderType" = "Opaque" }

            Cull Front

            CGPROGRAM
            #pragma surface surf _NoLight vertex:vert noshadow noambient
            #pragma target 3.0

            fixed4 _OutlineColor; // 외곽선 색상 변수
            float _OutlineWidth;  // 외곽선 두께 변수

            void vert(inout appdata_full v)
            {
                v.vertex.xyz += v.normal.xyz * _OutlineWidth; // _OutlineWidth를 사용하여 두께 조절
            }
            struct Input
            {
                float4 color:COLOR;
            };

            void surf(Input IN, inout SurfaceOutput o)
            {
                o.Emission = _OutlineColor.rgb; // _OutlineColor를 사용하여 색상 조절
                o.Alpha = 1;
            }

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

            Cull Back

            CGPROGRAM
            #pragma surface surf Lambert
            #pragma target 3.0

            sampler2D _MainTex;

            struct Input
            {
                float2 uv_MainTex;
            };

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

 

+++

 

문제 5

 

 

Shader "Custom/Dissolve"
{
    Properties
    {
        _MainTex("Albedo (RGB)", 2D) = "white" {}
        _NoiseTex("Noise Texture", 2D) = "white" {}
        _Cut("Cut", Range(0, 1)) = 0
        _Outline("Outline", Color) = (1,1,1,1)
        _OutlineWidth("Outline Width", Range(0, 100)) = 0
        _Thickness("Thickness", Range(1, 2)) = 1.1
    }
        SubShader
        {
            Tags { "RenderType" = "Transparent" "Queue" = "Transparent" }

            ZWrite On
            ColorMask 0

            CGPROGRAM
            #pragma surface surf _NoLight
            #pragma target 3.0

           
            struct Input
            {
                float4 color : COLOR;
            };
            void surf(Input IN, inout SurfaceOutput o)
            {
            }
            float4 Lighting_NoLight(SurfaceOutput s, float3 lightDir, float atten)
            {
                return 0;
            }
            ENDCG

            ZWrite Off

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

            sampler2D _MainTex;
            sampler2D _NoiseTex;
            float _Cut;
            float4 _Outline;
            
            float _Thickness;


            float _OutlineWidth;
            void vert(inout appdata_full v)
            {
                v.vertex.xyz += v.normal.xyz * _OutlineWidth; // _OutlineWidth를 사용하여 두께 조절
            }
            struct Input
            {
                float2 uv_MainTex;
            };

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


                float4 noiseColor = tex2D(_NoiseTex, IN.uv_MainTex);
                float alpha;
                if (noiseColor.r >= _Cut)
                    alpha = 1;
                else
                    alpha = 0;

                //노이즈 경계 색 입히기 
                float outline;
                if (noiseColor.r >= _Cut * _Thickness)
                    outline = 0;
                else
                    outline = 1;

                //o.Albedo = outline;

                o.Emission = _Outline.rgb * outline;
                o.Alpha = alpha;
            }
            ENDCG
        }
            FallBack "Diffuse"
}