그래픽스) 시험 내용 정리

1) 

찌그러지는 정도 조절하기

이동속도

잔상안보이기

 

Shader "Custom/Fire"
{
    // 인터페이스
    Properties
    {
        _FireTex ("Fire Texture 2D", 2D) = "white" {}   // 첫번째 이미지
        _NoiseTex ("Noise Texture 2D", 2D) = "white" {} // 두번째 이미지
        _AnimeSpeed("Anime Speed", Range(0.1, 1)) = 1    // 이미지 재생 속도
        _ImageCrushed("Image Crushed", Range(0.1, 1)) = 0.5  // 구겨지는 이미지 값 조절

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

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

        // 매개 변수
        sampler2D _FireTex;
        sampler2D _NoiseTex;
        float _AnimeSpeed;
        float _ImageCrushed;

        struct Input
        {
            // 변수 선언
            float2 uv_FireTex;
            float2 uv_NoiseTex;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // 데이터
            // 해당 이미지에 애니메이션 : float2(IN.해당이미지.x, IN.해당이미지.y - _Time.y)
            float2 uvNoiseTex = IN.uv_NoiseTex;
            float4 noiseColor = tex2D(_NoiseTex, uvNoiseTex + float2(0, _Time.y * _AnimeSpeed));



            // 데이터를 적용할 텍스쳐
            float4 fireColore = tex2D(_FireTex, IN.uv_FireTex + noiseColor.r * _ImageCrushed);


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

 

2)

골렘에게 마스킹해서 칠하기(클릭한 곳으로 이동하기)

4개 버택스 (torso. leftArm, rightArm, head)

버텍스컬러 칠하고 텍스쳐 블랜딩

애니메이션 적용

 

쉐이더

Shader "Custom/TestGolem"
{
    Properties
    {
        _Torso ("Torso (RGB)", 2D) = "white" {}
        _LeftArm ("LeftArm (RGB)", 2D) = "white" {}
        _RightArm ("RightArm (RGB)", 2D) = "white" {}
        _Head ("Head (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 200

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows
        #pragma target 3.0

        sampler2D _Torso;
        sampler2D _LeftArm;
        sampler2D _RightArm;
        sampler2D _Head;

        struct Input
        {
            float2 uv_Torso;
            float2 uv_LeftArm;
            float2 uv_RightArm;
            float2 uv_Head;
            float4 color : COLOR;
        };

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            // tex2D값 가져오기
            fixed4 torso = tex2D (_Torso, IN.uv_Torso);
            fixed4 leftArm = tex2D (_LeftArm, IN.uv_LeftArm);
            fixed4 rightArm = tex2D (_RightArm, IN.uv_RightArm);
            fixed4 head = tex2D (_Head, IN.uv_Head);

            // 브러쉬 그려온 값 구현
            //o.Albedo = IN.color.rgb;
            
            // lerp을 이용해 하나하나 식 적용하기
            o.Emission = lerp(torso.rgb, leftArm.rgb, IN.color.r);
            o.Emission = lerp(o.Emission, rightArm.rgb, IN.color.g);
            o.Emission = lerp(o.Emission, head.rgb, IN.color.b);

            // 핵심 을 출력하기
            o.Alpha = torso.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

 

스크립트

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

public class TestGolem : MonoBehaviour
{
    public float speed = 5.0f;
    private Vector3 targetPosition;
    private bool isMoving = false;
    public Animator animator;
    public Rigidbody ri;

    void Start()
    {
        targetPosition = transform.position;

        if (animator == null)
        {
            animator = GetComponent<Animator>();
        }
    }

    void Update()
    {
        if (Input.GetMouseButtonDown(0)) // 마우스 왼쪽 버튼 클릭
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;

            if (Physics.Raycast(ray, out hit))
            {
                targetPosition = hit.point;
                isMoving = true;
                // 클릭한 위치를 바라보도록 회전 설정
                Vector3 direction = (targetPosition - transform.position).normalized;
                direction.y = 0; // Y축 회전 방지
                transform.rotation = Quaternion.LookRotation(direction);
            }
        }

        if (isMoving)
        {
            MoveCharacter();
        }
    }

    void MoveCharacter()
    {
        Vector3 direction = (targetPosition - transform.position).normalized;
        float distance = Vector3.Distance(transform.position, targetPosition);

        if (distance > 0.1f)
        {
            transform.position += direction * speed * Time.deltaTime;
            this.animator.SetInteger("State", 1);
        }
        else
        {
            isMoving = false;
            this.animator.SetInteger("State", 0);
        }
    }
}

 

3)

홀로그램 만들기 해골

레이 간격과 움직이는 속도 제어

컬러변경

 

Shader "Custom/holo"
{
    Properties
    {
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _Color ("Rim Color", Color) = (1,1,1,1)
        _HoloSpeed("Holo Speed", Range(-10,10)) = 0
        _HoloLine("HoloLine", Range(1,10)) = 3
    }
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent" }

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

        sampler2D _MainTex;        
        float4 _Color;
        float _HoloSpeed;
        float _HoloLine;

        struct Input
        {
            float2 uv_MainTex;
            float3 viewDir;
            float3 worldPos;    // 월드 위치
            float2 _HoloSpeed;
            float2 _HoloLine;
        };


        void surf (Input IN, inout SurfaceOutput o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            //o.Albedo = 0;
            float speed = _Time.y * _HoloSpeed;

            // 프레넬 N dot V
            float rim = dot(o.Normal, IN.viewDir);
            float reverseRim = pow(1- rim, 3);
            o.Emission = _Color.rgb;

            // // 문서에 속도 응용 에러 있다 abs(sin(_Time.y * number)) 확인 
            // o.Emission = reverseRim * abs(sin(_Time.y * 10));
            //o.Alpha = reverseRim + sin(_Time.y * 0.5 + 0.5);
            
            float holo = pow(frac(IN.worldPos.g * _HoloLine - speed), 30);
            o.Alpha = reverseRim + holo;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

 

4)

아웃라인 쉐이더

2pass로 만들기

색상변경

두께조절

1Pass로 만들기(프레넬)

 

Shader "Custom/2Pass"
{
    Properties
    {
        _ShadowColor("Color", Color) = (1,1,1,1)
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _ShadowTex ("Shader Texture", Range(0, 0.03)) = 0.01
        _FresnelColor ("Fresnel Color", Color) = (1,1,1,1)
        _FresnelPower ("Fresnel Power", Range(1, 10)) = 2.0
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }

        Cull Front

        //1Pass
        CGPROGRAM
        #pragma surface surf _NoLight vertex:vert noshadow
        #pragma target 3.0

        sampler2D _MainTex;

        float _ShadowTex;
        float4 _Color;
        

        // vertex:vert 에 대한 함수 따로 추가
        void vert (inout appdata_full v)
        {
            // 외각선 굵기 조절 normal로 전체 크기를 조절 가능
            // 즉 normal * 길이 를 vertex.xyz축 전체만큼 더한다.
            v.vertex.xyz = v.vertex.xyz + (v.normal.xyz * _ShadowTex);
            
        }

        struct Input
        {
            float2 uv_MainTex;
        };


        void surf (Input IN, inout SurfaceOutput o)
        {
            // fixed4 c = tex2D (_MainTex, IN.uv_MainTex);
            // o.Emission = c.rgb + abs(sin(_Time.y));
            // o.Alpha = c.a;
            
            o.Emission = _Color.rgb;
        }

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

        Cull Back

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

        sampler2D _MainTex;
        float _FresnelPower;
        float4 _FresnelColor;

        struct Input
        {
            float2 uv_MainTex;            
            float3 viewDir;
        };

        void surf (Input IN, inout SurfaceOutput o)
        {
            float fresnel = pow(1.0 - dot(IN.viewDir, o.Normal), _FresnelPower);
            o.Emission = _FresnelColor.rgb * fresnel;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

 

5)

Diffuse Warping, Ramp Texture 적용해서 바바리안 및 악세서리 꾸미기