lhh3520's 공간박스

[MLAgents][Unity] 퍼포 더 코기 최신화

lhh3520 — Thu, 4 Aug 2022 15:00:57 +0900

2018년인가..

ML-Agent 기능이 처음 나오고 나서 써보다가

일이 바빠서 잊고 있었는데 최근에 관심이 다시 생겨서

최신 버전으로 테스트를 좀 해보고 싶어졌습니다.

2018년 당시에 샘플 프로젝트였던
퍼포 더 코기 라는게 있었는데

https://blog.unity.com/kr/technology/puppo-the-corgi-cuteness-overload-with-the-unity-ml-agents-toolkit

퍼포 더 코기 : Unity ML-에이전트 툴킷으로 탄생한 재롱둥이 | Unity Blog

게임 제작은 게임 컨셉 및 로직 정의, 에셋 및 애니메이션 제작, NPC 동작 지정, 난이도 및 밸런스 조정, 출시 전 실제 플레이어를 통한 게임 테스트 등 여러 까다로운 작업이 수반되는 창조적 과

blog.unity.com

아직 프로젝트 코드가 남아 있었고 (4년 가까이 지났는데..)

어차피 테스트용 3D 모델을 구해야 했는데 잘 됐다 싶어서

이 프로젝트를 최신화해서 머신러닝을

테스트해보는 것으로 가닥을 잡았습니다.

일단 기본적인 프로젝트를 생성합니다.

(유니티 2021.2.5f1 기준)

그다음 이전에 있던 프로젝트에서

필요한 리소스들을 (씬, 프리펩, 소스코드 같은 것들..)

가져옵니다.

물론 컴파일 에러가 바로 쏟아집니다.

예전에는 이런 아카데미와 브레인 개념이 있어서

아카데미를 만들고 브레인들을 세팅해서 학습 시켜주는 구조였는데

최신 버전에서는 이 구조가 바뀌고 그냥

Agent 정도만 구현해서 세팅해 주면 되는듯합니다.

(아주 간편해 졌습니다.)

그래서 일단 컴파일 에러가 나는 아카데미나 브레인 관련된

GameObject나 코드들은 지워 줍니다.

그다음

Window -> Package Manager 에서

필요한 패키지들을 추가해 줍니다.

ML Agents 추가.

TextMeshPro 추가

Cinemachine 추가

Post Processing 추가

그다음 아래와 같이 새로운 MLAgent을 임포트 해줍니다.

그리고 나머지 컴파일 에러 나는 것들을 최신화해 줍니다.

요런거.

또 요런거.

최신화된 DogAgent.cs의 코드

(에러의 거의 대부분이 DogAgent.cs여서 이것만 첨부합니다.)

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

using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
using Unity.MLAgentsExamples;

public class DogAgent : Agent
{
    [HideInInspector]
    // The target the dog will run towards.
    public Transform target; 

    // These items should be set in the inspector
    [Header("Body Parts")] 
    public Transform mouthPosition;
    public Transform body;
    public Transform leg0_upper;
    public Transform leg1_upper;
    public Transform leg2_upper;
    public Transform leg3_upper;
    public Transform leg0_lower;
    public Transform leg1_lower;
    public Transform leg2_lower;
    public Transform leg3_lower;

    // These determine how the dog should be able to rotate around the y axis
    [Header("Body Rotation")] 
    public float maxTurnSpeed;
    public ForceMode turningForceMode;

    [Header("Sounds")]
    // If true, the dog will bark. 
    // Note : This should be turned off during training...unless you want to hear a dozen dogs barking for hours
    public bool canBark;
    // The clips to use for the barks of the dog
    public List<AudioClip> barkSounds = new List <AudioClip>();
	AudioSource audioSourceSFX;

    JointDriveController jdController;
    
    [HideInInspector]
    // This vector gives the position of the target relative to the position of the dog
	public Vector3 dirToTarget;
    // This float determines how much the dog will be rotating around the y axis
    float rotateBodyActionValue; 
    // Counts the number of steps until the next agent's decision will be made
    int decisionCounter;

    // [HideInInspector]
    public bool runningToItem;
    // [HideInInspector]
    public bool returningItem;

    void Awake()
    {
        // Audio Setup
        audioSourceSFX = body.gameObject.AddComponent<AudioSource>();
        audioSourceSFX.spatialBlend = .75f;
        audioSourceSFX.minDistance = .7f;
        audioSourceSFX.maxDistance = 5;
        if(canBark)
        {
            StartCoroutine(BarkBarkGame());
        }

        //Joint Drive Setup
        jdController = GetComponent<JointDriveController>();
        jdController.SetupBodyPart(body);
        jdController.SetupBodyPart(leg0_upper);
        jdController.SetupBodyPart(leg0_lower);
        jdController.SetupBodyPart(leg1_upper);
        jdController.SetupBodyPart(leg1_lower);
        jdController.SetupBodyPart(leg2_upper);
        jdController.SetupBodyPart(leg2_lower);
        jdController.SetupBodyPart(leg3_upper);
        jdController.SetupBodyPart(leg3_lower);

    }

    public override void OnEpisodeBegin()
    {
        foreach(var bodyPart in jdController.bodyPartsDict.Values)
        {
            bodyPart.Reset(bodyPart);
        }

        body.rotation = Quaternion.Euler(0, Random.Range(0f, 360f), 0f);
    }

    public override void Heuristic(in ActionBuffers actionsOut)
    {

    }

    /// <summary>
    /// Add relevant information on each body part to observations.
    /// </summary>
    public void CollectObservationBodyPart(VectorSensor sensor, BodyPart bp)
    {
        sensor.AddObservation(bp.groundContact.touchingGround ? 1 : 0); // Is this bp touching the ground
                                                                        // 
        if(bp.rb.transform != body)
        {
            sensor.AddObservation(bp.currentXNormalizedRot);
            sensor.AddObservation(bp.currentYNormalizedRot);
            sensor.AddObservation(bp.currentZNormalizedRot);
            sensor.AddObservation(bp.currentStrength/jdController.maxJointForceLimit);
        }
    }

    /// <summary>
    /// The method the agent uses to collect information about the environment
    /// </summary>
    public override void CollectObservations(VectorSensor sensor)
    {
        sensor.AddObservation(dirToTarget.normalized);
        sensor.AddObservation(body.localPosition);
        sensor.AddObservation(jdController.bodyPartsDict[body].rb.velocity);
        sensor.AddObservation(jdController.bodyPartsDict[body].rb.angularVelocity);
        sensor.AddObservation(body.forward); //the capsule is rotated so this is local forward
        sensor.AddObservation(body.up); //the capsule is rotated so this is local forward

        foreach (var bodyPart in jdController.bodyPartsDict.Values)
        {
            CollectObservationBodyPart(sensor, bodyPart);
        }
    }


    /// <summary>
    /// Rotates the body of the agent around the y axis
    /// </summary>
    /// <param name="act"> The amount by which the agent must rotate</param>
    void RotateBody(float act)
    {
        float speed = Mathf.Lerp(0, maxTurnSpeed, Mathf.Clamp(act, 0, 1));
        Vector3 rotDir = dirToTarget; 
        rotDir.y = 0;
        // Adds a force on the front of the body
        jdController.bodyPartsDict[body].rb.AddForceAtPosition(
            rotDir.normalized * speed * Time.deltaTime, body.forward, turningForceMode); 
        // Adds a force on the back od the body
        jdController.bodyPartsDict[body].rb.AddForceAtPosition(
            -rotDir.normalized * speed * Time.deltaTime, -body.forward, turningForceMode); 
    }

    /// <summary>
    /// Allows the dog to bark
    /// </summary>
    /// <returns></returns>
    public IEnumerator BarkBarkGame()
    {   

        while(true)
        {
            //When we're returning the stick we should not bark because we have
            //a stick in our mouth :|>
            if(!returningItem)
            {
                //Choose one of the barking clips at random and play it.
                audioSourceSFX.PlayOneShot(barkSounds[Random.Range( 0, barkSounds.Count)], 1);
            }
            //Wait for a random amount of time (between 1 & 10 sec) until we bark again.
            yield return new WaitForSeconds(Random.Range(1, 10)); 
        }
    }

    /// <summary>
    /// The agent's action method. Is called at each decision and allows the agent to move
    /// </summary>
    /// <param name="vectorAction"> The actions that were determined by the policy</param>
    /// <param name="textAction"> The text action given by the policy</param>
    public override void OnActionReceived(ActionBuffers actions)
    {
        var bpDict = jdController.bodyPartsDict;
        var vectorAction = actions.ContinuousActions;

        // Update joint drive target rotation
        bpDict[leg0_upper].SetJointTargetRotation(vectorAction[0], vectorAction[1], 0);
        bpDict[leg1_upper].SetJointTargetRotation(vectorAction[2], vectorAction[3], 0);
        bpDict[leg2_upper].SetJointTargetRotation(vectorAction[4], vectorAction[5], 0);
        bpDict[leg3_upper].SetJointTargetRotation(vectorAction[6], vectorAction[7], 0);
        bpDict[leg0_lower].SetJointTargetRotation(vectorAction[8], 0, 0);
        bpDict[leg1_lower].SetJointTargetRotation(vectorAction[9], 0, 0);
        bpDict[leg2_lower].SetJointTargetRotation(vectorAction[10], 0, 0);
        bpDict[leg3_lower].SetJointTargetRotation(vectorAction[11], 0, 0);

        // Update joint drive strength
        bpDict[leg0_upper].SetJointStrength(vectorAction[12]);
        bpDict[leg1_upper].SetJointStrength(vectorAction[13]);
        bpDict[leg2_upper].SetJointStrength(vectorAction[14]);
        bpDict[leg3_upper].SetJointStrength(vectorAction[15]);
        bpDict[leg0_lower].SetJointStrength(vectorAction[16]);
        bpDict[leg1_lower].SetJointStrength(vectorAction[17]);
        bpDict[leg2_lower].SetJointStrength(vectorAction[18]);
        bpDict[leg3_lower].SetJointStrength(vectorAction[19]);

        rotateBodyActionValue = vectorAction[20];
    }    

    /// <summary>
    /// Update the direction vector to the current target;
    /// </summary>
    public void UpdateDirToTarget()
    {
        dirToTarget = target.position - jdController.bodyPartsDict[body].rb.position;

    }

    void FixedUpdate()
    {
        UpdateDirToTarget();

        if (decisionCounter == 0)
        {
            decisionCounter = 3;
            RequestDecision();
        }
        else
        {
            decisionCounter--;
        }

        RotateBody(rotateBodyActionValue); 

        // Energy Conservation
        // The dog is penalized by how strongly it rotates towards the target.
        // Without this penalty the dog tries to rotate as fast as it can at all times.
        var bodyRotationPenalty = -0.001f * rotateBodyActionValue;
        AddReward(bodyRotationPenalty);

        // Reward for moving towards the target
        RewardFunctionMovingTowards();
        // Penalty for time
        RewardFunctionTimePenalty();
    }
	
    /// <summary>
    /// Reward moving towards target & Penalize moving away from target.
    /// This reward incentivizes the dog to run as fast as it can towards the target,
    /// and decentivizes running away from the target.
    /// </summary>
    void RewardFunctionMovingTowards()
    {

		float movingTowardsDot = Vector3.Dot(
		    jdController.bodyPartsDict[body].rb.velocity, dirToTarget.normalized); 
        AddReward(0.01f * movingTowardsDot);
    }


    /// <summary>
    /// Time penalty
    /// The dog gets a pentalty each step so that it tries to finish 
    /// as quickly as possible.
    /// </summary>
    void RewardFunctionTimePenalty()
    {
        AddReward(- 0.001f);  //-0.001f chosen by experimentation.
    }

}

컴파일 에러를 없애고

FetchTrainingScene 씬을 열어 줍니다.

아래와 같이 트레이닝 그룹 1개만 남기고
기존에 있던 그룹들은 다 지워줍니다.

트레이닝 그룹 아래에 보면

CORGI 가 있는데 이걸 선택해 주고

인스펙터로 가서 끊어진 데이터들을 새로 연결해 줍니다.

이제 실행을 해보면 코기가

움찔움찔 움직이는 걸 볼 수 있습니다.

(아직 학습이 안되서 거의 가만히 있음..)

이제 학습을 위해서 위의 트레이닝 그룹을 여러 개 복사해 줍니다.

이제 샘플이나 기존에 있던 프로젝트에서

yaml 파일을 복사해 와서 이름을 바꿔주고

학습 항목 설정을 적절히 맞춰 줍니다.

그다음 아나콘다를 실행해서 mlagents

실행 환경을 적용시켜 줍니다.

https://lhh3520.tistory.com/369?category=839963

[Mac] Mac에서 아나콘다 설치하는 방법

머신 러닝을 배우고 테스트하는데 파이썬과 텐서 플로가 최소한으로 필요한데 이러한 것들을 좀 더 쉽게 관리할 수 있도록 도와주는 프로그램입니다. 일단 아래에 아나콘다 홈페이지로 갑니다.

lhh3520.tistory.com

그리고 위에서 만들었던 yaml 파일을 가지고

mlagents-learn 명령어를 실행해 줍니다.

mlagents-learn config/Corgi.yaml --run-id=Corgi01

실행하면 아래와 같이 유니티 로고가 그려지고

학습을 위한 연결이 완료 됩니다.

이제 이 상태로 에디터로 돌아가서

플레이를 시켜 학습을 진행해 줍니다.

꼬물꼬물 하면서 뭔가 학습하는 모습.

학습이 완료되고 나면 프로젝트 폴더 안 results 폴더에

.onnx 파일이 생성됩니다. (이전엔 .nn 이었는데 바뀌었네요)

학습이 어떻게 이루어졌는지 그래프로 볼 수도 있는데

콘솔에서 아래와 같이 실행하고

tensorboard --logdir results --port 6006

웹 브라우저에서

http://localhost:6006/

로 접속하면 텐서 보드를 보여줍니다.

학습이 다 완료되었으니

이제 다시 유니티로 돌아와서 아까 생성된 .onnx 파일을

프로젝트 폴더 안으로 옮겨 줍니다.

그다음 DogAgent에게

학습된 모델을 적용시켜 줍니다.

그리고 이제 실행을 시켜 보면

약간 어리숙(?) 하긴 하지만 잘 가져오는 걸 볼 수 있습니다.

(학습량이나 시간을 늘려주면 훨씬 좋아지겠네요)

[Unity] 유니티 Job System 간단 테스트

lhh3520 — Sun, 24 Apr 2022 16:02:44 +0900

유니티 2018.1 버전에서 공개된

잡 시스템 (Job System)에 대해서

공부도 할 겸 테스트 진행해 보았습니다.

간단하게 말하면 멀티 스레드를 쉽게 이용할 수 있게

만들어 놓은 시스템 정도로 생각하면 될 것 같습니다.

스레드를 사용하려고 하면 Race Condition이나

Context Switching 등등 신경 써야 될 것들이 많은데

그런 것 신경 안 쓰고 멀티 스레드 기능을 활용할 수 있으면

훨씬 편하고 좋을 것 같긴 하네요.

일단 아래 사이트를 참조해서 테스트했습니다.

(샘플용 메시도 제공해 주고 설명도 아주 잘 되어 있습니다)

https://www.raywenderlich.com/7880445-unity-job-system-and-burst-compiler-getting-started

Unity Job System and Burst Compiler: Getting Started

In this tutorial, you’ll learn how to use Unity’s Job System and Burst compiler to create efficient code to simulate water filled with swimming fish.

www.raywenderlich.com

유니티 2021.2.5f1 버전

기준 입니다.

일단.. 기본 프로젝트 세팅을 해주고

파도 느낌을 만들 샘플 메시를 불러옵니다.

그 다음.. 잡 시스템을 사용하기 위해서는

아래의 3가지 패키지가 필요합니다.

Burst

Jobs

Mathematics

Window -> Package Manager

로 가서 추가해 줍니다.

Burst, Mathematics 추가했고

현재 테스트 중인데 2021 기준으로 Jobs는

이미 포함되어 있어서 건너뜁니다.

이제 다시 돌아와서 처음 추가한 메시의 와이어 프레임을 보면

엄청 많은 버텍스들이 있는 걸 볼 수 있습니다.

요 버텍스 들의 위치들을 변경해서

파도 느낌을 줄 수 있게 해줄 예정입니다.

처음으로 잡 시스템을 쓰지 않고

그냥 Update에서 계산해서 돌려 보도록 코드를 짜봅니다.

using System.Collections;
using System.Collections.Generic;
using Unity.Mathematics;
using UnityEngine;

public class WaveGeneratorUpdate : MonoBehaviour
{
    [Header("Wave Parameters")]
    public float waveScale;
    public float waveOffsetSpeed;
    public float waveHeight;

    [Header("References and Prefabs")]
    public MeshFilter waterMeshFilter;
    private Mesh waterMesh;

    private List<Vector3> waterVertices;
    private List<Vector3> waterNormals;

    private void Start()
    {
        waterMesh = waterMeshFilter.mesh;
        waterMesh.MarkDynamic();

        waterVertices = new List<Vector3>(waterMesh.vertices);
        waterNormals = new List<Vector3>(waterMesh.normals);
    }

    private void Update()
    {
        MakeNoise();

        waterMesh.SetVertices(waterVertices);

        waterMesh.RecalculateNormals();
    }

    private void MakeNoise()
    {
        for (int ii = 0; ii < waterVertices.Count; ii++)
        {
            if (waterNormals[ii].z <= 0f)
                continue;

            var vertex = waterVertices[ii];

            var x = vertex.x * waveScale + waveOffsetSpeed * Time.time;
            var y = vertex.y * waveScale + waveOffsetSpeed * Time.time;
            float2 pos = math.float2(x, y);
            float noiseValue = noise.snoise(pos);

            waterVertices[ii] = new Vector3(vertex.x, vertex.y, noiseValue * waveHeight + 0.3f);
        }
    }
}

파도의 운동은 여러 입자들이 순차적으로

x좌표는 Sin값, y좌표는 Cos값 정도 넣어서 원운동을 연속적으로 하면서

느낌을 내줄 수 있는데 위 예제에서는 간단히 z 값만 바꿔줬네요.

하여튼.. 이렇게 하고 실행해 보면

대략 30~35 프레임 정도 나오는 걸 볼 수 있습니다.

이제 비교를 위해 잡 시스템을 사용한 코드로 변경해 줍니다.

/*
 * Copyright (c) 2020 Razeware LLC
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * Notwithstanding the foregoing, you may not use, copy, modify, merge, publish, 
 * distribute, sublicense, create a derivative work, and/or sell copies of the 
 * Software in any work that is designed, intended, or marketed for pedagogical or 
 * instructional purposes related to programming, coding, application development, 
 * or information technology.  Permission for such use, copying, modification,
 * merger, publication, distribution, sublicensing, creation of derivative works, 
 * or sale is expressly withheld.
 *    
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Jobs;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;

public class WaveGeneratorJobs : MonoBehaviour
{
    [Header("Wave Parameters")]
    public float waveScale;
    public float waveOffsetSpeed;
    public float waveHeight;

    [Header("References and Prefabs")]
    public MeshFilter waterMeshFilter;
    private Mesh waterMesh;

    private NativeArray<Vector3> waterVertices;
    private NativeArray<Vector3> waterNormals;

    private JobHandle meshModificationJobHandle;
    private UpdateMeshJob meshModificationJob;

    private void Start()
    {
        waterMesh = waterMeshFilter.mesh;
        waterMesh.MarkDynamic();

        waterVertices = new NativeArray<Vector3>(waterMesh.vertices, Allocator.Persistent);
        waterNormals = new NativeArray<Vector3>(waterMesh.normals, Allocator.Persistent);
    }

    private void Update()
    {
        meshModificationJob = new UpdateMeshJob()
        {
            vertices = waterVertices,
            normals = waterNormals,
            offsetSpeed = waveOffsetSpeed,
            time = Time.time,
            scale = waveScale,
            height = waveHeight
        };

        meshModificationJobHandle = meshModificationJob.Schedule(waterVertices.Length, 64);
    }

    private void LateUpdate()
    {
        meshModificationJobHandle.Complete();

        waterMesh.SetVertices(meshModificationJob.vertices);

        waterMesh.RecalculateNormals();
    }

    private void OnDestroy()
    {
        waterVertices.Dispose();
        waterNormals.Dispose();
    }

    // 실제 Job 이 실행되는 구조체
    private struct UpdateMeshJob : IJobParallelFor
    {
        public NativeArray<Vector3> vertices;

        [ReadOnly]
        public NativeArray<Vector3> normals;

        public float offsetSpeed;
        public float scale;
        public float height;

        public float time;

        private float Noise(float x, float y)
        {
            float2 pos = math.float2(x, y);
            return noise.snoise(pos);
        }

        public void Execute(int i)
        {
            if (normals[i].z > 0f)
            {
                var vertex = vertices[i];
                float noiseValue = Noise(vertex.x * scale + offsetSpeed * time, vertex.y * scale + offsetSpeed * time);
                vertices[i] = new Vector3(vertex.x, vertex.y, noiseValue * height + 0.3f);
            }
        }
    }
}

이렇게 적용하고 실행해 보면..

대략 80 정도의 프레임이 나오면서

확실히 성능 향상이 있는 걸 보여줍니다.

유니티 메인 스레드 하나를 쓰면서 병목현상을

일으키는 것보다는 멀티 스레드로 분산해서 처리하니

확실히 효율적이긴 한 듯합니다.

추가적으로 성능 향상을 시켜주는 기능이 있는데

버스트 컴파일러를 이용하는 것입니다.

LLVM 컴파일러 프레임워크를 바탕으로

고급 최적화를 사용해서 성능을 효율적으로

활용하게 해주는 기술입니다.

그럼 이제 버스트 컴파일러를 사용하도록 코드를 짜줍니다.

/*
 * Copyright (c) 2020 Razeware LLC
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * Notwithstanding the foregoing, you may not use, copy, modify, merge, publish, 
 * distribute, sublicense, create a derivative work, and/or sell copies of the 
 * Software in any work that is designed, intended, or marketed for pedagogical or 
 * instructional purposes related to programming, coding, application development, 
 * or information technology.  Permission for such use, copying, modification,
 * merger, publication, distribution, sublicensing, creation of derivative works, 
 * or sale is expressly withheld.
 *    
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Jobs;
using Unity.Collections;
using Unity.Burst;
using Unity.Jobs;
using Unity.Mathematics;

public class WaveGeneratorBurst : MonoBehaviour
{
    [Header("Wave Parameters")]
    public float waveScale;
    public float waveOffsetSpeed;
    public float waveHeight;

    [Header("References and Prefabs")]
    public MeshFilter waterMeshFilter;
    private Mesh waterMesh;

    private NativeArray<Vector3> waterVertices;
    private NativeArray<Vector3> waterNormals;

    private JobHandle meshModificationJobHandle;
    private UpdateMeshJobWithBurst meshModificationJob;

    private void Start()
    {
        waterMesh = waterMeshFilter.mesh;
        waterMesh.MarkDynamic();

        waterVertices = new NativeArray<Vector3>(waterMesh.vertices, Allocator.Persistent);
        waterNormals = new NativeArray<Vector3>(waterMesh.normals, Allocator.Persistent);
    }

    private void Update()
    {
        meshModificationJob = new UpdateMeshJobWithBurst()
        {
            vertices = waterVertices,
            normals = waterNormals,
            offsetSpeed = waveOffsetSpeed,
            time = Time.time,
            scale = waveScale,
            height = waveHeight
        };

        meshModificationJobHandle = meshModificationJob.Schedule(waterVertices.Length, 64);
    }

    private void LateUpdate()
    {
        meshModificationJobHandle.Complete();

        waterMesh.SetVertices(meshModificationJob.vertices);

        waterMesh.RecalculateNormals();
    }

    private void OnDestroy()
    {
        waterVertices.Dispose();
        waterNormals.Dispose();
    }

    [BurstCompile]  // <-- 요 어트리뷰트만 추가해 주면 끝.
    private struct UpdateMeshJobWithBurst : IJobParallelFor
    {
        public NativeArray<Vector3> vertices;

        [ReadOnly]
        public NativeArray<Vector3> normals;

        public float offsetSpeed;
        public float scale;
        public float height;

        public float time;

        private float Noise(float x, float y)
        {
            float2 pos = math.float2(x, y);
            return noise.snoise(pos);
        }

        public void Execute(int i)
        {
            if (normals[i].z > 0f)
            {
                var vertex = vertices[i];
                float noiseValue = Noise(vertex.x * scale + offsetSpeed * time, vertex.y * scale + offsetSpeed * time);
                vertices[i] = new Vector3(vertex.x, vertex.y, noiseValue * height + 0.3f);
            }
        }
    }
}

사용법이 정말 쉬운데..

그냥 기존에 만들어진 잡 구조체 위에

[BurstComplie] 어트리뷰트만 추가해 주면 끝입니다.

이제 실행해 보면

대략 110 ~ 120 프레임을 왔다 갔다 하는데

확실히 성능 향상이 있네요.

유니티의 잡 시스템 기능을 테스트해보면서

뭔가 대량의 연산이 필요한 곳에 적절히 사용하면

확실히 성능 면에서 효과를 볼 수 있을 것 같습니다.

Neople

lhh3520 — Fri, 22 Apr 2022 21:06:06 +0900

Neople Career

(참여 프로젝트)

모바일 던파

다운로드 링크

[ PC 버전 ]

https://dnfm.nexon.com/

던전앤파이터 모바일

최초 레이드 '로터스 레이드' Update, coming soon

dnfm.nexon.com

[ iOS 앱스토어 ]

https://apps.apple.com/kr/app/%EB%8D%98%EC%A0%84%EC%95%A4%ED%8C%8C%EC%9D%B4%ED%84%B0-%EB%AA%A8%EB%B0%94%EC%9D%BC/id1448979486

‎던전앤파이터 모바일

‎당신의 잠들어 있는 액션 본능을 일깨울 시간! 모두가 새롭게 시작하는 진짜 던전앤파이터! ▶ 게임 소개 ◀ ■ 오리지널 액션쾌감 던전앤파이터 모바일! 터치로 느끼는 원작의 강렬한 콤보

apps.apple.com

[ 구글 플레이 ]

https://play.google.com/store/apps/details?id=com.nexon.mdnf&hl=ko&gl=US

던전앤파이터 모바일 - Google Play 앱

당신의 잠들어 있는 액션 본능을 일깨울 시간! 어디서나 액션쾌감! 던전앤파이터 모바일 정식 출시!

play.google.com

[Unity] URP 프로젝트에서 Camera Stacking 하는 방법

lhh3520 — Fri, 22 Apr 2022 20:59:03 +0900

말 그대로 카메라를 쌓아서 오버레이 하는 방법 입니다.

https://docs.unity3d.com/Packages/com.unity.render-pipelines.universal@7.2/manual/camera-stacking.html

Camera Stacking | Universal RP | 7.2.1

Camera Stacking In the Universal Render Pipeline (URP), you use Camera Stacking to layer the output of multiple Cameras and create a single combined output. Camera Stacking allows you to create effects such as a 3D model in a 2D UI, or the cockpit of a veh

docs.unity3d.com

유니티 2021.2.5f1 버전

기준 입니다.

일단 기본적으로 메인 카메라가 있습니다.

요런 모양으로 비추고 있습니다.

이제.. 메인 카메라 뒷부분에 깔릴 카메라를 만들 차례인데

일단 카메라에 보여질 공간을 꾸며 줍니다.

대충 다른 카메라에 보여질 공간을 꾸며준 다음에

카메라를 하나 생성해 줍니다.

카메라를 선택하고 인스펙터를 살펴보면

아래처럼 Camera -> Render Type 이라는게 있는데

적절한 조건에 맞게 세팅해 줍니다.

[ 1 ]

Base : 기본적으로 렌더할 타입 (뒤에 깔림)

[ 2 ]

Overlay : 앞쪽으로 오버레이 해서 렌더할 타입

일단.. 별들은 뒷쪽에 나와야 하니까

Base 로 선택해 줬습니다.

아래처럼 일단 별들이 잘 나오고 있고요..

이제 메인 카메라로 가서 렌더 타입을

Overlay 로 설정해 줍니다.

설정 후 다시 Base가 될 카메라로 돌아와서

Overlay로 설정했던 카메라를 Stack 항목 부분에 추가해 줍니다.

아래처럼 추가가 되는데

원하는 만큼 스택해서 쌓을 수 있게 되어 있네요.

이제 Game 창으로 와서 보면

카메라들이 제대로 스택되어 있는걸 볼 수 있습니다.

[Unity] URP 프로젝트에서 SkyBox 변경하는 방법

lhh3520 — Fri, 22 Apr 2022 09:24:34 +0900

Unity URP 프로젝트에서 기본으로 설정되어 있는

스카이 박스를 교체하는 방법 입니다.

유니티 2021.2.5f1 버전

기준 입니다.

프로젝트를 생성하면 아래와 같이

기본적으로 스카이 박스가 설정되어 있습니다.

기본 스카이박스

Window -> Rendering -> Lighting

클릭해서 라이팅 팝업을 열어 줍니다.

Lighting 팝업 오픈

라이팅 팝업을 열고

Environment 탭을 선택합니다

교체하려고 하는 스카이박스 매터리얼을

아래 화살표 영역에 넣어서 교체해 줍니다.

스카이박스 매터리얼 교체

스카이박스 교체완료.

[Shader] 유니티 쉐이더를 이용한 미세면 분포 효과 구현

lhh3520 — Sun, 5 Dec 2021 21:17:25 +0900

물리 기반 렌더링(PBR)을 공부하다 보면

자주 사용되는 모델인

Cook-Torrance BRDF 모델을 접하게 되는데

$$f(l, v) = \frac{F(l, h)}{4}\frac{D(h)G(l,v,h)}{(\vec{N}\cdot \vec{L})(\vec{N}\cdot \vec{V})}$$

이전 포스팅에서는 기하학에

[Shader] 유니티 쉐이더를 이용한 기하학 효과 구현

lhh3520 — Sun, 5 Dec 2021 12:25:29 +0900

물리 기반 렌더링(PBR)을 공부하다 보면

자주 사용되는 모델인

Cook-Torrance BRDF 모델을 접하게 되는데

$$f(l, v) = \frac{F(l, h)}{4}\frac{D(h)G(l,v,h)}{(\vec{N}\cdot \vec{L})(\vec{N}\cdot \vec{V})}$$

이전 포스팅에서는 프레넬에

[Shader] 유니티 쉐이더를 이용한 프레넬 효과 구현

lhh3520 — Fri, 3 Dec 2021 13:21:25 +0900

물리 기반 렌더링(PBR)을 공부하다 보면

자주 사용되는 모델인

Cook-Torrance BRDF 모델을 접하게 되는데

$$f_{s} = \frac{F}{\pi}\frac{DG}{(\vec{N}\cdot \vec{L})(\vec{N}\cdot \vec{V})}$$

최근 모델은 대신 4를 나눠준다고 합니다.

$$f(l, v) = \frac{F(l, h)}{4}\frac{D(h)G(l,v,h)}{(\vec{N}\cdot \vec{L})(\vec{N}\cdot \vec{V})}$$

뭐.. 어쨌건..

모델을 보게되면 프레넬 항이 존재합니다.

먼저 프레넬에 대해서 조금 알아보자면

모든 빛은 매질을 만났을때 반사되거나

흡수 되거나 굴절이 되도록 되어있는데

이 과정에서

매질마다 가지는 반사률이나 굴절률이

다르기 때문에 특정한 매질에서 얼마 만큼의 빛이

반사되는지를 알아내는 공식이 프레넬 공식입니다.

사진출저: Real-Time Rendering, 3rd Edition.

이 공식을 통해서 특정 매질이

어떤 각도에서 어느정도의 반사율을 가지는지

알아낼 수 있습니다.

뭔가 복잡한 것 같지만

실생활에서 이러한 효과는 의외로 쉽게

접했을 수도 있을것 같습니다.

아래의 사진을 보면

사진출저: https://gamedevforever.com/35

가까운 곳의 물은 안쪽이

반사되지 않고 내부를 볼 수 있지만

멀리에 있는 물의 표면에는 주변 환경이

반사되는 강도가 강한걸 볼 수 있습니다.

추가로

이 굴절되는 과정에서 조금 특이한 현상이 생기는데

특정 각도에서는 굴절이 되지 않고 정반사가 이루어지는

각도가 생긴다는 것입니다.

사진출저: 위키피디아

이러한 각도를 Critical Angle 이라고 하고

이 각도를 구하는 공식은 아래와 같습니다.

$$\Theta_{c} = arcsin(\frac{n2}{n1})$$

이 현상도 실생활에서 볼 수가 있는데

어두운 곳에서 사진을 촬영할때

뒤에 조명을 놓고 터트려서 피사체의

외곽을 강조하면서 사진을 찍거나

뒷부분에 빛이 비출 때

외곽선이 빛이나는 현상이

이것과 연관된다고 할 수 있겠습니다.

(게임에서는 림라이트라고도 하죠)

사진출저: 사이버펑크 2077 (팔뚝이나 머리 가장자리 부분에 빛이 반사되는 효과)

이정도 알아보고

물리기반 렌더링을 사용할때

이용되는 프레넬 효과를 유니티에서

한번 구현해 보겠습니다.

일단 적당히 환경을 세팅해 놓고

쉐이더파일과 매터리얼을 만들어서

원형 구에 씌워 줍니다.

유니티에서 기본 제공되는 쉐이더를 입혔는데

옛날에 비해서 뭔가 느낌이 그럴싸(?) 해졌네요.

여기에서 일단 프레넬 효과를

좀 더 잘 확인할 수 있도록 앰비언트를 없애고

색깔을 0으로 세팅했습니다.

#pragma surface surf Lambert noambient
#pragma target 3.0

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

주변광없애고 색깔을 없앤 모습.

게임에서 많이 사용되는 프레넬 공식중에

Schlick 공식이 있다는데 이 공식을 사용해 줍니다.

$$R(\Theta) = R_{o} + (1 - R_{o})(1 - cos\Theta)^{5}$$

여기서 R0는 반사율 입니다.

$$R_{o} = (\frac{n1-n2}{n1+n2})^{2}$$

보통 반사율값은 메탈릭값으로 넣어준다고 해서

메탈릭 값으로 넣어 봅니다.

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

	// Schlick Approximation Fresnel
	// 굴절률값 대신 metalic 값으로 넣음.
	float NoV = saturate(dot(o.Normal, IN.viewDir));
	float exponential = pow(1 - NoV, 5);
	float fresnel = _Metallic + (1 - _Metallic) * exponential;			
	o.Emission = fresnel;
}

이렇게 해주면

물체의 가장자리가 반사되어 빛이나는

효과를 만들어 볼 수 있습니다.

전체 쉐이더 코드

Shader "Custom/SchlickApproximation" 
{
	Properties {
		_Color ("Color", Color) = (1,1,1,1)
		_MainTex ("Albedo (RGB)", 2D) = "white" {}		
		_Metallic ("Metallic", Range(0,1)) = 0.0
	}
	SubShader {
		Tags { "RenderType"="Opaque" }
		LOD 200

		CGPROGRAM
		#pragma surface surf Lambert
		#pragma target 3.0

		sampler2D _MainTex;

		struct Input {
			float2 uv_MainTex;
			float3 viewDir;
		};

		half _Metallic;
		fixed4 _Color;

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

			// Schlick Approximation Fresnel
			// 반사율값 대신 metalic 값으로 넣어둠.
			float NoV = saturate(dot(o.Normal, IN.viewDir));
			float exponential = pow(1 - NoV, 5);
			float fresnel = _Metallic + (1 - _Metallic) * exponential;			
			o.Emission = fresnel;
		}

		ENDCG
	}
	FallBack "Diffuse"
}

[수학] 입체각 (스테라디안)

lhh3520 — Wed, 1 Dec 2021 23:42:10 +0900

각도를 표시할때 육십분법이 아닌

호의 길이로 표시하는 방법을 호도법이라고 하는데

https://lhh3520.tistory.com/378

[수학] 호도법

일반적인 육십분법처럼 각도를 30°, 60°, 90° 처럼 표시하는 것이 아닌 호의 길이를 이용해 각도를 표시하는 방법. 원주는 2πr 로 나타낼 수 있고 특정 부채꼴을 기준으로 중심각의 크기를 ϕ, 반

lhh3520.tistory.com

입체각은 평면에서 각도를 표시하는 호도법에서

한차원 더 나아가 3차원 공간에서의 각을 표시하는 방법입니다.

반지름이 r 인 구의 표면에서 면적이 A인

값을 1 스테라디안 이라고 하는데 아래 그림과 같다.

사진출저: 나무위키

또한, 반지름이 r인 구면 위의 한 영역의 면적이 A 일때,

입체각 Ω는 아래와 같이 정의할 수 있다.

$$\Omega=\frac{A}{r^2}$$

[수학] 호도법

lhh3520 — Tue, 30 Nov 2021 23:06:07 +0900

사진출저: 나무위키

일반적인 육십분법처럼 각도를 30°, 60°, 90° 처럼

표시하는 것이 아닌 호의 길이를 이용해 각도를 표시하는 방법.

원주는 2πr 로 나타낼 수 있고

특정 부채꼴을 기준으로 중심각의 크기를 ϕ,

반지름의 길이를 r 이라고 할때

호의 길이는 아래와 같이 나타낼 수 있다.

1라디안은 대략 ≒ 57.2958° 이고

1° 로 계산하면 아래와 같다.

각도에 따른 삼각함수표

사진출저: 나무위키