ReaderWriterLock 은 EnterWriterLock 호출 되기 전까진 EnterReadLock과 ExitReadLock 구간을 lock 없이 읽을 수 있는데 EnterWriterLock 이 호출 되면 이때 lock 이 점유되어 놓아지기 전까지 EnterReadLock ~ ExitReadLock 구간을 다른 스레드가 접근하지 못하게 된다
// SpinLock.IsThreadOwnerTrackingEnabled
static void SpinLockSample2()
{
// Instantiate a SpinLock
SpinLock sl = new SpinLock();
// These MRESs help to sequence the two jobs below
ManualResetEventSlim mre1 = new ManualResetEventSlim(false);
ManualResetEventSlim mre2 = new ManualResetEventSlim(false);
bool lockTaken = false;
Task taskA = Task.Factory.StartNew(() =>
{
try
{
sl.Enter(ref lockTaken);
Console.WriteLine("Task A: entered SpinLock");
mre1.Set(); // Signal Task B to commence with its logic
// Wait for Task B to complete its logic
// (Normally, you would not want to perform such a potentially
// heavyweight operation while holding a SpinLock, but we do it
// here to more effectively show off SpinLock properties in
// taskB.)
mre2.Wait();
}
finally
{
if (lockTaken) sl.Exit();
}
});
int ddd = Interlocked.CompareExchange(ref _lockecd, desired, expected);
CompareExchange 이걸 풀어보면
if( _lockecd == expected )
{
_lockecd = desired;
return expected;
}else{
return _locked;
}
같으면 expected 를 리턴하고
다르면 _locked 를 리턴한다
그리고 같으면 _locked 가 desired 값으로 바뀐다
그래서 아래 코드는 값이 바뀔때까지 계속 실행된다
// AddToTotal safely adds a value to the running total.
public float AddToTotal(float addend)
{
float initialValue, computedValue;
do
{
// Save the current running total in a local variable.
initialValue = totalValue;
// Add the new value to the running total.
computedValue = initialValue + addend;
// CompareExchange compares totalValue to initialValue. If
// they are not equal, then another thread has updated the
// running total since this loop started. CompareExchange
// does not update totalValue. CompareExchange returns the
// contents of totalValue, which do not equal initialValue,
// so the loop executes again.
}
while (initialValue != Interlocked.CompareExchange(ref totalValue,
computedValue, initialValue));
// If no other thread updated the running total, then
// totalValue and initialValue are equal when CompareExchange
// compares them, and computedValue is stored in totalValue.
// CompareExchange returns the value that was in totalValue
// before the update, which is equal to initialValue, so the
// loop ends.
// The function returns computedValue, not totalValue, because
// totalValue could be changed by another thread between
// the time the loop ends and the function returns.
return computedValue;
}
주석 설명들에 어떤것과 어떤것이 비교가 되는지 빠져 있어 헷갈린다
ms 홈페이지 설명글은 항상 느끼는 거지만 글자만 있지 내용을 파악하기엔 내용이 부실하게 빠져 있거나 부족하거나 이상한 부분들이 많다
간단한 기능인데 : on, off 기능으로 에디터에서 default 값을 어떻게 선택하느냐에 따라 on, off 중 하나만 out 으로 내보낸다
여기서 맨 밑의 Keyword는 약간 다른 종류인데, 이 Keyword 하위에 있는 요소들(Boolean, Enum)은 셰이더의 정적 분기를 위한 노드라고 한다.
경우에 따라서 출력되는 게 다른 상황에서, 셰이더의 Variant를 만들어내기 위해서 나온 기능이라고 하는데,
최적화에는 별로 좋지 않다고 하고..
나뉘는 경우의 수마다 다른 셰이더로 쳐 진다고 한다.
직접 사용해보자. 우선은 Keyword 아래의 Boolean부터 꺼낸다.
이 Boolean은 인스펙터 창에서 체크박스 형태로 나타나게 되는데,
그 체크박스의 체크 여부에 따라서 최종 결과물이 달라지는 형태이다.
즉, 체크박스에 체크가 되어있다면 위에서 On의 결과물이 Out으로 나가게 될 것이고,
반대로 체크가 되어있지 않다면 Off의 결과물이 Out으로 나가게 될 것이다.
간단하게 예제를 만들어보자.
아까 위에서 만들었던 곱하기의 결과물이 On으로, 그리고 곱하기를 하지 않은 Sample Texture 2D 상태가 Off로 들어오도록 노드를 연결해준다.
그런 다음 Boolean을 Base Color에 연결해준다.
그러면 이런 모습이 되고,
직접 씬에서 본다면
이렇게 Boolean의 On/Off 여부에 따라 결과물이 달라지는 것을 볼 수 있다.
Boolean Keywords
Boolean Keywords are either on or off. This results in two shader variants. Shader Graph uses the value in theReferencename field for the on state, and automatically defines the off state as an underscore (_).
To expose a Boolean Keyword in the Material Inspector, itsReferencename must include the_ONsuffix. For example,BOOLEAN_A506A032_ON.
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace ServerCore
{
class Lock_Basic
{
//1. 전역변수 메모리 값을 레지스터에 갖고오고, 레지스터 값을 증가시키고, 그 값을 메모리 값에 넣는다
static object _obj = new object();
static int number = 0;
static void Thread_1()
{
for (int i = 0; i < 10000; i++)
{
Monitor.Enter(_obj);
number++;
Monitor.Exit(_obj);
}
}
static void Thread_2()
{
for (int i = 0; i < 10000; i++)
{
Monitor.Enter(_obj);
number--;
Monitor.Exit(_obj);
}
}
static void Main(string[] args)
{
Task t1 = new Task(Thread_1);
Task t2 = new Task(Thread_2);
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
Console.WriteLine(number);
}
}
}
이와 같이 실행한다면 증감연산자는 원자적으로 동작하지 않음에도 불구하고 잘 작동하는 점을 확인할 수 있을 것이다.
아시다시피 동시 다발적으로 쓰레드가 공유 변수에 접근시 문제가 발생했고, 이를 우리는Critical Section(임계영역)이라고 첫 시간때 이야기를 하였다.
그러나 Monitor.Enter, Monitor.Exit을 통해 이를 방지하여 이 사이의 코드는 사실상 싱글 쓰레드와 같은 상태가 되어버렸다. 이러한 조치를 Mutual Exclusion(상호배제)라고도 설명하였다.
Enter, Exit은 쉽게 이야기하면 1인용 화장실과 같다. Enter(화장실 들어가서 문잠금)를 통해 한 사람이 화장실을 이용하고 있으면 Exit(화장실을 다 쓰고 문 열기)하기 전까지 바깥의 사람들은 화장실을 사용할 수 없다.
적어도 그 순간만큼은 소스코드에 다른 쓰레드가 끼어들 껀덕지가 없다는 뜻이다.
하지만, Monitor의 경우에도 단점이 있는데, 만약 Exit를 선언하지 않게 된다면 어떻게 될까? 화장실은 계속 이용하고 있고, 영영 화장실을 나가지 않게 되면 바깥의 사람들은 주구장창 기다려야 할 것이다.
이러한 상황을 데드락이라고 하는데, 이는 다음 시간에 자세히 살펴볼 것이다.
따라서 Monitor를 쓰는 경우 모든 경우(예외 처리)까지 Exit을 고려해야 하는 골치아픈 단점이 있어 거의 대부분 쓰이지 않는다.
처럼 Enter, Exit으로 샌드위치처럼 코드를 감쌌지만
lock(_obj){
//소스코드
}
Lock에선 이와 같이 소스코드를 넣어주면, lock 구절이 끝난 이후엔 자동으로 Monitor.Exit을 하게 되는 효과를 가지게 된다.
lock은 thread-unsafe(안전하지 않은 스레드)코드를 안전하게 사용하고자 할때 사용한다. 즉, 동기화 처리를 할때 사용하는 구문이다.
그렇다면, thread-unsafe한 코드는 어떤 코드인가 다음 예제를 보자.
static public class Division { static int num1 = 100, num2 = 5;
메모리 베리어는 membar, memory fence, fence instruction으로 알려져 있다. 메모리 배리어는 CPU나 컴파일러에게 barrier 명령문 전 후의 메모리 연산을 순서에 맞게 실행하도록 강제하는 기능이다. 즉 barrier 이전에 나온 연산들이 barrier 이후에 나온 연산보다 먼저 실행이 되는게 보장되어야 하는 것이다.
Memory barrier는 현대 CPU가 성능을 좋게 하기 위해 최적화를 거쳐 순서에 맞지 않게 실행시키는 결과를 초래할 수 있기 때문에 필수적이다. 이런 메모리 연산(load/store)의 재배치는 single 쓰레드로 실행할 때는 알아차리기 어렵지만, 제대로 관리되지 않는 한 병행적으로 작동되는 프로그램과 디바이스 드라이버에서 예상할 수 없는 결과를 초래하기도 한다. 싱글 쓰레드에서는 하드웨어가 명령어 통합성을 강제하기 때문에 싱글 쓰레드에서는 문제가 되지 않는다.
즉 정리하자면 성능을 좋게 만드려고 코드의 순서를 바꿔서 실행시킬 수 있는데, 이런 것을 막고 순서대로 코드가 실행되게 하도록 강제하는 것이다. 아래 간략화 된 코드를 보자. 실제로 동작하는 코드는 아니고, 핵심적인 부분만 남겨놓은 코드다.
static void Thread1() {
y = 1; // Store y
r1 = x; // Load x
}
static void Thread2() {
x = 1; // Store x
r2 = y; // Load y
}
static void Main(string[] args) {
while(true) {
x = y = r1 = r2 = 0; // 반복문의 초기부분마다 모든 변수의 값을 0으로 할당한다.
Task t1 = new Task(Thread1);
Task t2 = new Task(Thread2);
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
if (r1 == 0 & r2 == 0)
break;
}
System.out.println("While문이 break되었다.");
}
메모리 연산인 store과 load를 하는 Thread1, Thread2가 있고, 이를 Main 함수 안에서 실행시킨다. 위의 동작을 봤을 때 우리가 기대하는 것은 초기에 0으로 설정되어 있는 x, y 값이 1로 바뀌고 r1, r2에 이어서 1이 할당되면서 while 문이 계속 반복되어 무한 루프를 도는 것이다. 하지만 실제로 실행해 보면(위의 코드가 실행되는 건 아니다)While문이 break되었다.로그가 찍히는 경우가 생긴다.
어떻게 이런 일이 가능한 것일까? 분명 while문을 빠져 나오는 조건은 r1과 r2가 모두 0일 때였다. 이 반복문을 빠져나왔다는 것은 원래 아래의 순서대로 실행되어야 할 코드가
x = 0 // 반복문 안
y = 0
x = 1 // 쓰레드 안
y = 1
r1 = x // 쓰레드 안
r2 = y
실제로는 아래와 같이 실행되는 것이다.
x = 0 // 반복문 안
y = 0
r1 = x // 쓰레드 안
r2 = y
// 여기에서 반복문 빠져나옴!
x = 1 // 쓰레드 안
y = 1
성능의 최적화를 위해서 코드의 순서를 이렇게 뒤집어서 실행시킬 수 있는데, 싱글 쓰레드에서는 문제가 되지 않지만 멀티 쓰레드에서는 문제가 된다. 따라서 이를 방지하기 위해, 명령어를 순서대로 실행시키기 위해 메모리 배리어를 사용한다.
static void Thread1() {
y = 1; // Store y
Thread.MemoryBarrier(); // 메모리 배리어
r1 = x; // Load x
}
static void Thread2() {
x = 1; // Store x
Thread.MemoryBarrier(); // 메모리 배리어
r2 = y; // Load y
}
static void Main(string[] args) {
while(true) {
x = y = r1 = r2 = 0; // 반복문의 초기부분마다 모든 변수의 값을 0으로 할당한다.
Task t1 = new Task(Thread1);
Task t2 = new Task(Thread2);
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
if (r1 == 0 & r2 == 0)
break;
}
System.out.println("While문이 break되었다.");
}
위의 코드와 같이 메모리 배리어를 설정하면 배리어 위의 코드가 배리어 아래의 코드와 순서가 바뀌어서 실행될 수 없게 된다. 이렇게 코드의 실행 순서를 보장해 주는 것이 메모리 배리어의 역할이다.
종류
메모리 배리어는 메모리 read/write가 내가 예상한 대로 실행되게 하는 명령어의 클래스다. 예를 들어 full fence(barrier)는 fence 전의 모든 read/write 는 fence 이후의 read/write 을 실행시키기 전에 모두 실행되어야 한다는 것이다. 메모리 배리어의 종류는 아래와 같다.
Full Memory Barrier : read/write 를 둘 다 막는다.
Store Memory Barrier : write만 막는다.
Load Memory Barrier : read만 막는다.
메모리 배리어는 하드웨어 개념임을 기억해야 한다. 높은 레벨의 언어에서는 mutex와 세마포어를 이용해서 이를 해결한다. 낮은 레벨에서 메모리 배리어를 사용하고 메모리 배리어를 명시적으로 사용하는 것을 구현하는 것은 불필요할 수 있다. 메모리 배리어의 사용은 하드웨어 구조를 자세히 공부한 것이 전제가 되어야 하고, 애플리케이션 코드보다는 디바이스 드라이버에서 많이 사용된다.
메모리 배리어(Memory Barrier)
이 코드를 읽고 실행해보자.
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
namespace ServerCore
{
class Program
{
static int x = 0;
static int y = 0;
static int r1 = 0;
static int r2 = 0;
static void Thread_1()
{
y = 1; // Store y
r1 = x; // Load x
}
static void Thread_2()
{
x = 1; // Store x
r2 = y; // Load y
}
static void Main(string[] args)
{
int count = 0;
while(true)
{
count++;
x = y = r1 = r2 = 0;
// t1, t2야 일해!
Task t1 = new Task(Thread_1);
Task t2 = new Task(Thread_2);
t1.Start();
t2.Start();
// t1 t2가 일이 끝날 때까지 Main Thread는 대기
Task.WaitAll(t1, t2);
// t1,t2가 x,y,r1,r2를 모두 1로 바꾸어 주었으므로
// 이론상으로는 무한반복 되어야 한다.
if (r1 == 0 && r2 == 0)
break;
}
Console.WriteLine($"{count}번 만에 r1, r2가 0이 되었습니다. ");
}
}
}
싱글쓰레드에서는 절대로 마지막 반복문을 빠져나올 수 없다.
하지만 생각보다 반복문을 잘 빠져나오는 것을 알 수 있다.
이는, 멀티쓰레드에서는하드웨어 최적화가 적용되기 때문이다.
즉, 하드웨어가 쓰레드(Thread_1,Thread_2)에 준 연산들이 서로 상관이 없는 연산이라고 생각하면 의 연산 순서를 임의로 바꾸어서 연산하는 경우도 있기 때문이다.
이 때 메모리 배리어(Memory Barrier)를 사용한다.
메모리 배리어를 사용한 를 실행해보면 반복문을 빠져나오지 못한다.
메모리 베리어를 통해코드 재배치와가시성을 확보 할 수 있다.
using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
namespace ServerCore
{
class Program
{
static int x = 0;
static int y = 0;
static int r1 = 0;
static int r2 = 0;
static void Thread_1()
{
y = 1; // Store y
Thread.MemoryBarrier(); // notify other Thread stored 'y'
r1 = x; // Load x
}
static void Thread_2()
{
x = 1; // Store x
Thread.MemoryBarrier(); // notify other Thread stored 'x'
r2 = y; // Load y
}
static void Main(string[] args)
{
int count = 0;
while(true)
{
count++;
x = y = r1 = r2 = 0;
// t1, t2야 일해!
Task t1 = new Task(Thread_1);
Task t2 = new Task(Thread_2);
t1.Start();
t2.Start();
// t1 t2가 일이 끝날 때까지 Main Thread는 대기
Task.WaitAll(t1, t2);
// Memory Barrier로 코드 재배치와 가시성이 확보된 상태
if (r1 == 0 && r2 == 0)
break;
}
Console.WriteLine($"{count}번 만에 r1, r2가 0이 되었습니다. ");
}
}
}
In Unreal Engine blueprint widget, you can create different shapes through an array of points. There is no line drawing in the user widget with an array of points in C++, so we will useUWidgetBlueprintLibrary. In order to draw the shape, we must useUWidgetBlueprintLibrary::DrawLines. And then another trouble awaits us — we cann’t overrideOnPaint.
All animals are equal, but some animals are more equal than others.
- 사운드를 구현하려면 소리를 내는 파트(Audio Source)와 소리를 듣는 파트(Audio Listener) 그리고 음원 파일(Audio Clip)이 필요하다
- 유니티로 import된 음원 파일을 오디오 클립이라고 부른다
- 오디오는 일반적으로 Singleton 방식을 이용해서 하나의 게임오브젝트가 사운드 출력을 총괄하도록 관리한다
AudioListener 컴포넌트
- 이 컴포넌트는 Main Camera에 기본 컴포넌트로 미리 추가되어 있다. 이 컴포넌트에 대해서는 별도로 속성을 이용해 제어할 수 없다
- 이 컴포넌트는 모든 게임오브젝트에 붙일 수 있지만 일반적으로 게임세계를 바라보는 유저의 눈에 해당하는 카메라 게임오브젝트에 포함되는 게 좋으며 조작하고 있는 캐릭터에 붙이기도 한다
- Audio Listener는 씬 내에 하나만 존재해야 한다(카메라가 여러 대인 경우 Audio Listener가 모든 카메라에서 활성화되어 있지는 않은지 꼭 확인하자). 반대로 Audio Source는 씬 내에 여러 개가 있을 수 있다
Audio Source 컴포넌트 1
Audio Source 컴포넌트 2
Audio Source 컴포넌트
- 씬 내에서 음원을 재생하는 컴포넌트
AudioClip: 재생할 음원 파일
Output: 재생되는 음원의 출력을 특정 Audio Listener 또는 Audio Mixer로 설정(?)
Mute: 음원이 재생되고 있는 상태로 음소거시킨다
Bypass Effects: 모든 Filter effects를 즉시 켜거나 끈다
Bypass Listener Effects: 모든 Listener effects를 즉시 켜거나 끈다
Bypass Reverb Zones: 모든 Reverb Zones를 즉시 켜거나 끈다
Play On Awake: 컴포넌트가 활성화 상태일 때 씬 실행과 동시에 음원을자동재생한다. 체크해제할 경우 스크립트에서 Play 함수로 재생할 수 있다
Loop: 반복재생 여부 설정
Priority: 씬 내의 여러 음원들 중에서 재생 우선순위 설정. default는 128이며 0이 최우선 순위, 256이 마지막 순위이다
Volume: Audio Listener로부터 1유닛(=1미터) 만큼 떨어지 거리에 있을 때를 기준으로 볼륨 설정
Pitch
Stereo Pan
Spatial Blend: 3D엔진이 Audio Source에 영향을 주는 정도를 설정
Reverb Zone Mix
3D Sound Settings: Spatial Blend에 값에 따라 비례적으로 영향을 받는다
Doppler Level: doppler effect의 적용 정도를 설정
Spread: 3D 스테레오나 멀티채널 사운드일 경우 스피커 공간에서의 spread angle을 조절
Volume Rolloff: Audio Source로부터 거리가 멀어질수록 볼륨이 감소하는 세 가지 Preset 옵션을 제공. 하단의 Curved Editor에서 감소 효과를 세부적으로 조절 가능
Min Distance: 볼륨을 100%로 들을 수 있는 범위. 3D공간에서 소리를 '더 크게' 만드려면 값을 높인다. 이 범위를 벗어나면 소리가 점점 줄어든다
Max Distance: 볼륨을 50% 이상으로 들을 수 있는 최대 범위. 즉, Max Distance 를 벗어나면 볼륨이 더 이상 감소하지 않고 50%로 들린다
Audio Clip의 인스펙터 뷰
Audio Clip
Force To Mono: 멀티채널(스테레오 포함) 음원을 싱글채널(모노)로 변환한다(down-mixing). 변환 후에는 기존 음원보다 소리가 작아지므로 데이터를 peak-
normalize 한다
Normalize: 변환 과정에서 normalize 여부를 설정
Load In Background: 체크하면 오디오 클립의 로드를 메인 쓰레드가 아닌 별개의 쓰레드에서 delayed time에 진행하므로 메인 쓰레드를 block하지 않는다. 유니티는 씬이 플레이되기 전에 씬 내에서 사용할 모든 오디오 클립을 로드해놓도록 기본설정되어 있으므로 이 속성은 default로 체크해제 되어 있다. Audio Clip 컴포넌트가 Background에서 음원을 로드하는 중이면 음원 로드를 완료할 때까지 컴포넌트는 작동이 지연된다
Ambisonic: 음원파일에 Ambisonic-encoded audio가 포함된 경우 체크. Listener의 방향orientation에 따라 회전하는 soundfield를 지원하는 포맷으로 음원을 저장
한다. XR이나 360도 영상에서 유용하게 사용된다
Load Type: 유니티가 실시간으로 음원을 불러올 때 사용할 방식을 설정
Decompress On Load: 오디오 파일을 압축되지 않은 상태로 메모리에 올리는 방식. 용량이 큰 오디오 파일은 성능상 오버헤드를 발생시키므로 용량이 작은 오디오 파일에
적합하다. 메모리는 많이 사용하지만, CPU 자원은 덜 소모한다
Compressed In Memory: 오디오 파일을 압축된 상태로 메모리에 올리는 방식. 실행할 때 압축을 해제하기 때문에 약간의 성능상 오버헤드를 발생시킨다. 큰 사이즈의
오디오 파일에 적합하다. 품질을 떨어뜨리면 파일크기를 줄일 수 있으므로 음질손상이 없는 범위 내에서 적절하게 Quality 값 설정
Streaming: Persistent Memory(HDD, Flash Driver)에 저장된 오디오 파일을 스트리밍 방식으로 재생한다. 따라서 오디오 파일을 저장하기 위한 메모리가 필요 없다
Preload Audio Data: 씬이 로드될 때 씬에서 사용할 모든 오디오 클립도 미리 로드하도록 설정. default로 체크되어 있다. 체크해제할 경우 AudioSource.Play/PlayOneShot 함수가 처음 호출되는 시점에 음원이 로드된다. 또는 AudioSource.LoadAudioData 함수로 원하는 시점에 로드하고 AudioSource.UnloadAudioData 함수로 언로드할 수 있다. 오디오 클립을 처음 재생하는 시점에 음원이 로드될 경우 렉이 발생할 수 있다는 점을 유의하자
Compression Format: 압축 포맷은 오디오 파일의 용도에 따라 다르게 설정해야 한다. 유니티에서 지원하는 오디오 압축 포맷의 종류는 다음과 같다
PCM: 음질이 좋은 대신 파일의 크기가 비교적 크기 때문에 효과음처럼 재생시간이 짧은 오디오 파일에 적합하다(비압축 포맷)
ADPCM: 압축률이 PCM 대비 3.5배이기에 파일의 크기가 작아서 메모리는 덜 쓸 수 있는 반면 CPU 자원은 좀 더 사용한다. 노이즈가 발생하기에 노이즈가 약간 있더라도
크게 상관 없는 총 소리나 발걸음 소리 같은 음원에 적합하다
Vorbis / MP3: 중간길이 정도의 효과음 또는 배경음악에 적합하다. PCM에 비해 음질은 떨어지지만 압축률(Quality 설정)을 조절할 수 있다. 압축률이 100%이면 PCM
과 동일해진다. 보통 70% 정도로 설정
*Vorbis의 Quality 값을 낮추게 되면 압축이 일어나므로 값을 다시 올리더라도 원래 상태로 돌아오지 않는다(다시 로드해야함)
HEVAG: PS Vista 고유의 압축 포맷으로 ADPCM과 유사하다
Quality: 압축되는 오디오 클립에 대한 압축률 설정. Vorbis 포맷에만 적용된다
Sample Rate Setting
Preserve Sample Rate: default 설정. 기존 음원파일의 sample rate를 유지
Optimize Sample Rate: 음원파일을 분석해서 가장 높은 주파수에 맞게 sample rate를 최적화
Override Sample Rate: sample rate를 수동으로 override 한다
오디오 설정 팁
- import한 오디오 클립은 2개의 채널로 이뤄져 있다(스테레오 방식. 각 채널은 좌,우 스피커로 구분해서 소리를 따로 보낸다). 그러나 음향 효과를 극대화한 게임이 아니라면 모노(소리의 방향구분 X)로 변환하는 걸 권장한다. 특히 모바일 게임의 경우 스테레오 사운드는 용량 부족과 성능 저하의 원인이 될 수 있다
*유니티는 스테레오, 모노 방식 외에도 최대 8개까지의 멀티채널을 지원한다
- raw 파일 음원은 용량이 크다. wav 파일은 용량이 크지만 바로 출력할 수 있기에 실행속도가 빠르다. mp3 파일은 용량이 작지만 압축 해제한 후 출력되기에 실행속도가 상대적으로 느리다(딜레이 발생) *유니티는 aif, wav, mp3, ogg 포맷의 음원을 지원한다
1. wav 파일: 즉시 출력돼야 하는 효과음(칼이나 총알의 충돌 등)에 사용
2. mp3 파일: 약간의 딜레이가 허용되는 인물의 대사나 배경음악에 사용
- 배경음악이나 환경음은 대부분 용량이 크기에 실행시 미리 압축을 풀어서 메모리에 보관할 경우 가용 메모리가 줄어든다. 따라서 용량이 큰 음원은 다음과 같은 import 설정을 권장한다
1. Streaming+Vorbis
2. Compressed in Memory+Vorbis+Quality(70%)
- 오디오의 발생 빈도나 오디오 파일의 크기에 따라서는 다음과 같은 import 설정을 권장한다
1. 자주 발생하며 파일크기가 작은 경우: Decompress On Load+PCM(or ADPCM)
2. 자주 발생하며 파일크기가 중간인 경우: Compressed in Memory+ADPCM
3. 가끔 발생하며 파일크기가 작은 경우: Compressed in Memory+ADPCM
4. 가끔 발생하며 파일크기가 중간인 경우: Compressed in Memory+Vorbis
- 음원은 import될 때 설정된 플랫폼(build target)에 적합한 타입(Load Type)으로 변환(re-encode)된다(default는 Decompress On Load+Vorbis). Load Type은 원본을 크게 손상시키지 않는 PCM이나 Vorbis/MP3 타입이 주로 쓰인다. PCM은 비압축포맷이기에 메모리에서 바로 읽어들일 수 있으므로 CPU의 부담이 덜하다. Vorbis/MP3 포맷은 불필요한 소리 정보를 잘라내는 방식으로 압축한다. ADPCM은 메모리 성능과 CPU 성능 사이에서 타협한 방식인데, PCM에 비해 CPU를 살짝 더 사용하지만 꽤 많이 압축되기에 메모리 부담을 줄인다.
Scripting API
AudioSource
publicAudioClipclip:재생할 default 오디오 클립. 다음에 재생할 오디오 클립을 clip에 담는 방법은 아래 코드 참고
흔히 쓰이는 렌더링 효과 중에는 한 단계에서 GPU가 자원 R에 자료를 기록하고, 이후의 한 단계에서 그 자원 R의 자료를 읽어서 사용하는 식으로 구현하는 것들이 많다. 그런데 GPU가자원에 자료를 다 기록하지 않았거나기록을 아예 시작하지도 않은 상태에서 자원의 자료를 읽으려 하면문제가 생긴다. 이를자원 위험 상황(Resource hazard)이라고 부른다.
이 문제를 해결하기 위해, Direct3D는 자원들에게상태를 부여한다. 새로 생성된 자원은 기본 상태(default state)로 시작한다. 임의의 상태 전이를 Direct3D에게'보고'하는 것은 전적으로응용 프로그램의 몫이다.
여러 리소스 상태들
이 덕분에, GPU는 상태를 전이하고 자원 위험 상황을 방지하는 데 필요한 일들을 자유로이 진행할 수 있다. 예를 들어 텍
응용 프로그램이 상태 전이를 Direct3D에게 보고함으로써, GPU는 자원 위험을 피하는 데 필요한 조치를 할 수 있다.(이를테면 모든 쓰기 연산이 완료되길 기다린 후에 자원 읽기를 시도하는 등)
상태 전이를 보고하는 부담을 프로그래머에게 부여한 것은성능때문이다. 응용 프로그램 개발자는 그러한 전이들이 언제 일어나는지 미리 알고 있다. 만일 이러한 전이를 자동으로 추적하게 한다면 성능에 부담이 생긴다.
자원 상태 전이는전이 자원 장벽(Transition resource barrier)들의 배열을 설정해서 지정한다. 배열을 사용하는 덕분에, 한 번의 API 호출로 여러 개의 자원을 전이할 수 있다. 코드에서 자원 장벽은D3D12_RESOURCE_BARRIER_DESC구조체로 서술된다.
이 코드는 화면에 표시할 이미지를 나타내는 텍스처 자원을 제시 상태(Presentation state)에서 렌더 대상 상태로 전이한다. 자원 장벽이 명령 목록에 추가됨을 주목하기 바란다. 전이 자원 방벽이라는 것을,GPU에게 자원의 상태가 전이됨을 알려주는 하나의 명령이라고 생각하기 바란다. 명령을 통해서 자원 상태 전이를 알려주는 덕분에, GPU는 이후의 명령들을 실행할 때 자원 위험 상황을 피하는 데 필요한 단계들을 밟을 수 있다.
This static class provides several easy game-oriented ways of generatingpseudorandom numbers.
The generator is anXorshift 128algorithm, based on the paperXorshift RNGsby George Marsaglia. It is statically initialized with a high-entropyseedfrom the operating system, and stored in native memory where it will survive domain reloads. This means that the generator is seeded exactly once on process start, and after that is left entirely under script control.
For more details on the seed, including how to manage it yourself, seeInitState. To learn how to save and restore the state ofRandom, seestate.
Versus System.Random
This class has the same name as the .NET Framework classSystem.Randomand serves a similar purpose, but differs in some key ways:
Static vs instanced UnityEngine.Randomis a static class, and so its state is globally shared. Getting random numbers is easy, because there is no need tonewan instance and manage its storage. However, static state is problematic when working with threads or jobs (the generator will error if used outside the main thread), or if multiple independent random number generators are required. In those cases, managing instances ofSystem.Randomwould be a better option.
Float upper bounds are inclusive All properties and methods inUnityEngine.Randomthat work with or derive work from float-based randomness (for examplevalueorColorHSV) will use aninclusiveupper bound. This means that it is possible, though as rare as any other given value, for the max to be randomly returned. In contrast,System.Random.NextDouble()has anexclusivemaximum, and will never return the maximum value, but only a number slightly below it.
Performance Methods inUnityEngine.Randomhave been measured to be between 20% and 40% faster than their equivalents inSystem.Random.
Name resolution ambiguity Because the classes share the nameRandom, it can be easy to get aCS0104"ambiguous reference" compiler error if theSystemandUnityEnginenamespaces are both brought in viausing. To disambiguate, either use an aliasusing Random = UnityEngine.Random;, fully-qualify the typename e.g.UnityEngine.Random.InitState(123);, or eliminate theusing Systemand fully-qualify or alias types from that namespace instead.
Software companies have a problem. There’s not enough candidates that can code C++. This was the consensus in a webinar from ProfitView, a crypto trading tools developer, on high frequency trading using C++. Anthony Peacock, formerly aquantat both Citi andCitadelsaid “it’s impossible to find people with a really high level of C++ skills which is exactly what every trading company wants.”
This isn’t just a British or American issue, nor is it one specific to high frequency trading. Rainer Grimm, who has been a professionalC++ trainersince 2008, affirmed that C++ education in Germany is equally “terrible” and added that “there’s a big demand for C++ not only in this domain but also the automotive” industry.
Where are all the C++ programmers? People are seemingly scared away from the language by a terrible stigma: the notion that it is a legacy program. With big names in tech such as Microsoft Azure CEO Mark Russinovich calling people to “deprecate” C++ “for the sake of security and reliability,”in favour of Rust, this is hardly surprising.
However, reports of C++'s death may be premature. ProfitView CEO Richard Hickling, a former software engineer at Barclays and Bank of America, said “the death of C++ has been reported many times.” Hickling pointed to Java, which has long “seemed to be replacing C++ itself,” but hasn't.
So where have all the C++ developers gone? The Stack Overflow Survey 2022 reported almost a drop of almost two percentage points in respondents this past year using C++ (from 24.3% to 22.5%), even while the percentage of professional developers using it rose. The good news, though, is that 34.7% of respondents learning to code are using C++, placing it in the top 6 programming languages of that category.
The real problem is that C++ is neither easy nor loved. Rust got an 87% approval rate in the "most loved" category of the Stack Overflow Survey. However, only 9.3% of respondents used Rust at all and only 8.8% did so professionally. C++, meanwhile, languished at 48%.
Even so, C++ regularly appears in the top 4 of the TIOBE index, earning it a place in their “big 4.”
The reality is that there are plenty ofC++ jobsavailable in finance, and that compared to other languages there are comparatively few people to fill them. The language may be hard. But it's also worth it.
시작점에서 끝점까지 이동 할때 노란색 화살표가 가리키는 곳으로 가게 되면 더 먼 경로로 가게 된다는 것을 알 수 있는데
Astar 에선 거리 측정을 두가지로 한다
1 현재 플레이어 위치와 목표 지점
2 현재 플레이어 위치 기준 이동 누적 거리가 얼마나 되는가
1,2 이것을 합산하여 거리 비교 판단을 하게 되어 더 가까운 쪽을 우선적으로 거리를 선택하여 도착점 까지 가게 되어 최단 경로를 구하게 됩니다 (최단 경로는 종점에서 역으로 시작점으로 가면서 현재 점의 부모 위치인 역으로 올라가는 방식입니다)
즉 여기선 아래쪽의 최단 경로를 찾게 된다는 애기가 됩니다
알고리즘 처리는 우선순위 큐를 활용해 현재 후보 노드들 중에서 합산 거리 가장 가까운 노드 기준으로 계속 탐색을 하는 방식입니다
코드는 4방향과 8방향이 있는데
4방향은 거리 10, 14를 모두 1로 처리해놓으면 됩니다
using System;
using System.Collections.Generic;
using System.Text;
namespace Algorithm
{
class Pos
{
public Pos(int y, int x) { Y = y; X = x; }
public int Y;
public int X;
}
class Player
{
public int PosY { get; private set; }
public int PosX { get; private set; }
Random _random = new Random();
Board _board;
enum Dir
{
Up = 0,
Left = 1,
Down = 2,
Right = 3
}
int _dir = (int)Dir.Up;
List<Pos> _points = new List<Pos>();
struct Node : IComparable<Node>
{
public int F;
public int G;
public int X;
public int Y;
int IComparable<Node>.CompareTo(Node other)
{
return F == other.F ? 0 : (F < other.F ? 1 : -1);
}
}
public void Initialize(int posY, int posX, Board board)
{
PosY = posY;
PosX = posX;
_board = board;
AStar();
}
void AStar()
{
//점수 매기기
//F = G + H
//F = 최종 점수 (작을 수록 좋음, 경로에 따라 달라짐)
//G = 시작점에서 해당 좌표까지 이동하는데 드는 비용 ( 작을 수록 좋음, 경로에 따라 달라짐 ), 현재 노드에서 열린 다음 노드까지
//H = 목적지에서 얼마나 가까운지 (작을 수록 좋음, 고정)
//open (거리 계산용) 배열과
//closed 이미 방문한 노드인지 파악하기 위한배열
//이 둘의 배열이 각각 존재한다
// open 한 x,y 위치에 목적지까지 거리가 얼마나 되는지 거리 계산 후 저장한다 그렇지 않은것들은 max distance, H 와 유사
//오픈 리스트에 있는 정보들 중에서, 가장 좋은 후보를 뽑기 위해 => 우선순위 큐를 쓴다 => 저장 되는 기준은 거리가 짭을 수록 순위가 높은 것
//방문 하게 되면 closed 가 된다, 방문한 곳은 더이상 조사하지 않는다
//이동할수 있는 노드라면 예약을 해 놓는다, 상 하 좌우 좌표 확인해서 예약 한다(open)
//F = G(현재 노드에서 다음 노드까지 거리) + H(현재 노드에서 목적지 까지의 거리H)
//open 된 것들 중에서 계산한 F 가 open 되어진 즉 이전에 계산했던 open 거리보다 보다 작다면 더이상 계산 안함
//=> open 된것과 현재 노드 기준 사방향을 보면서 가장 적은 비용의 F 를 구해서 다시 open[nextX, nextY] = F 에 넣어 준다
//그리고 이것을 우선순위 Q 에 넣어 준다
//4방향일때
// int[] deltaX = new int[] { 0, -1, 0, 1 };
// int[] deltaY = new int[] { -1, 0, 1, 0 };
// int[] cost = new int[] { 1, 1, 1, 1 };
//8방향 일때
int[] deltaX = new int[] { -1, 0, 1, 0, -1, 1, 1, -1 };
int[] deltaY = new int[] { 0, -1, 0, 1, -1, -1 , 1, 1 };
int[] cost = new int[] { 10, 10, 10, 10, 14, 14, 14, 14 };
bool[,] closed = new bool[_board.Size, _board.Size];
int[,] open = new int[_board.Size, _board.Size];
Pos[,] parent = new Pos[_board.Size, _board.Size];
for(int i=0;i<_board.Size;++i )
{
for (int j = 0; j < _board.Size; ++j)
{
open[i, j] = int.MaxValue;
}
}
PriorityQueue<Node> pq = new PriorityQueue<Node>();
//초기 H
open[PosY, PosX] = 10 * Math.Abs(_board.DestX - PosX) + Math.Abs(_board.DestY - PosY);
pq.Push(new Node() { F= open[PosY, PosX], G=0, X = PosX, Y = PosY });
parent[PosY, PosX] = new Pos(PosY, PosX);
while(pq.Count > 0)
{
//현재 후보군들 중에서 목표와 가장 근접한(계산식상) 후보를 하나 뽑는다
Node node = pq.Pop();
//방문했던 노드는 건너띔
if(closed[node.Y, node.X])
{
continue;
}
closed[node.Y, node.X] = true;
if (node.X == _board.DestX && node.Y == _board.DestY)
{
break;
}
//4방향으로 이동 할수 있는 노드인지 확인해서 가능하다면 예약(open) 에 거리 계산 한다
for (int i = 0; i < deltaY.Length; ++i)
{
int nextX = node.X + deltaX[i];
int nextY = node.Y + deltaY[i];
//테두리를 벗어나지 않은 경우 and 벽이 아니며 and 방문을 안했었다면 새로운 open 노드를 찾는다
if ((nextX < 0 || nextX >= _board.Size || nextY < 0 || nextY >= _board.Size) ||
(_board.Tile[nextY, nextX] == Board.TileType.Wall) ||
closed[nextY, nextX])
{
continue;
}
int g = node.G + cost[i];
//예약 가능 다음 노드 후보들에 대한 거리 계산을 하고
//목적지와 다음 노드 같의 거리 임으로 이 차이가 더 작은 곳으로
int h = 10 * Math.Abs(_board.DestX - nextX) + Math.Abs(_board.DestY - nextY);
//이전에 했었던 거리 계산이 더 작다면 skip
if(open[nextY, nextX] < g + h)
{
continue;
}
//거리를 갱신한다 더 짧은 거리로
open[nextY, nextX] = g + h;
pq.Push(new Node() { F = g + h, G = g, X = nextX, Y = nextY });
parent[nextY, nextX] = new Pos(node.Y, node.X);
}
}
calculatePath(parent);
}
void calculatePath(Pos[,] parent)
{
int x = _board.DestX;
int y = _board.DestY;
while(parent[y,x].X != x || parent[y, x].Y != y)
{
_points.Add(new Pos(y, x));
Pos pos = parent[y, x];
x = pos.X;
y = pos.Y;
}
_points.Add(new Pos(y, x));
_points.Reverse();
}
const int MOVE_TICK = 10;
int _sumTick = 0;
int _lastIndex = 0;
public void Update(int deltaTick)
{
if (_lastIndex >= _points.Count)
return;
_sumTick += deltaTick;
if (_sumTick >= MOVE_TICK)
{
_sumTick = 0;
PosY = _points[_lastIndex].Y;
PosX = _points[_lastIndex].X;
_lastIndex++;
}
}
}
}
노란 블럭 : 이동 경로
녹색 : 플레이어
붉은색 : 종점
왼쪽 상단 : 시작점
단점 : 목표하는대상과 거리가 멀 수록 성능이 떨어진다 => 조사 해야 하는 주변 블락 들이 많아지게 됨으로
장점 : BFS 보다 주변 환경이 반영된 좀 더 빠른 길 찾기가 가능하다, BFS 는 조사하는 범위가 계속 커진다
astar 는 BFS 보다는 조사 범위가 타일 하나의 누적 이동 거리+ 플레이어의 위치에서 목표지점까지의 거리
를 고려하게 됨으로 좀 덜 커질 수 있다
거리 찾는데 Astar 도 느린건 마찬가지다 그렇다면?
JPS : 대상지점까지 거리를 찾는건 Astar 와 유사한데 길을 찾을때 대상 목표지점과 플레이어 사이에 벽같은게 있다면 벽면의 외각 부분에 우선순위가 높아 그쪽을 먼저 향해 가는 방식으로 주변 모든 타일을 게속 탐색하면서 가는 방식보다 성능이 빠르다
출발 -> B -> A 로 가는 경로가 누적적으로 구해지면서 A에 도달했을때 기존 누적값과 누적해서 공통인 노드에 도달했을때 즉 A 에 도달했을때 누적된 것 중 더 빠른 거리를 경로로 선택하는 것
using System;
namespace GraphTraversal
{
class Graph
{
// -1 은 연결 안된 상태를 표시
int[,] adj = new int[6, 6]
{
{ -1, 15, -1, 35, -1, -1 },
{ 15, -1, 5, 10, -1, -1 },
{ -1, 5, -1, -1, -1, -1 },
{ 35, 10, -1, -1, 5, -1 },
{ -1, -1, -1, 5, -1, 5 },
{ -1, -1, -1, -1, 5, -1 },
};
public void Dijikstra(int start)
{
bool[] visited = new bool[6];
int[] distance = new int[6];
Array.Fill(distance, Int32.MaxValue);
int[] parent = new int[6];
distance[start] = 0; //자기자신은 0 거리로 만든다
parent[start] = start; //자기자신의 부모는 자기자신으로
while (true)
{
// 제일 좋은 후보를 찾는다.
// 가장 유력한 정점의 거리와 번호를 저장한다.
int closet = Int32.MaxValue;
int now = -1;
for (int i = 0; i < 6; i++)
{
// 이미 방문한 정점은 스킵
if (visited[i])
continue;
// 아직 발견(예약)된 적이 없거나, 아직 방문하지 않고 거리만 계산한 노드 중에서 가장 짧은 노드를 찾아내기 위한 과정
if (distance[i] == Int32.MaxValue || distance[i] >= closet)
continue;
closet = distance[i];
now = i;
}
//now : 아직 방문하지 않은 노드 중 가장 짧은 거리가 짧은 노드
if (now == -1)
break;
visited[now] = true;
for (int next = 0; next < 6; next++)
{
// 연결되지 않은 정점은 스킵한다
if (adj[now, next] == -1)
continue;
// 이미 방문한 정점은 스킵
if (visited[next])
continue;
//now : 1 ,
//next : 3
// 새로 조사된 정점의 최단 거리를 계산한다.
// 15 + 10
int nextDist = distance[now] + adj[now, next];
// 이전까지 누적해서 계산 했던 노드 길이distance[next]보다,
// 현재 계산하고있는 누적 길이(nextDist)가 더 작다면 next Dist 즉 더 짧은 경로로 변경한다
if (nextDist < distance[next])
{
distance[next] = nextDist; //해당 노드의 현재 까지 짧은 거리
parent[next] = now; //해당 노드의 현재까지 짧은 거리의 부모
//각 노드에 누적된 거리가 계속 갱신 됨으로
}
}
}
}
}
class Program
{
static void Main(string[] args)
{
Graph dijik = new Graph();
dijik.Dijikstra(0);
}
}
}
실행 결과
벨만 포드 알고리즘과 다익스트라 알고리즘의 가장 큰 차이점은 벨만 포드 알고리즘은 방향 그래프에서음의 가중치를 지닌 간선이 존재해도 사용할 수 있다라는 점입니다.따라서 음의 가중치를 가진 방향 그래프를 주면서 최단 거리를 구하라고 한다면 다익스트라 알고리즘이 아닌 벨만 포드 알고리즘을 사용해야 합니다.
보드에 출구(목적지)를 표시해야 한다. Board 클래스에 DestY DestX 프로퍼티를 정의해서 렌더링 할 때 목적지를 노란색으로 표시하도록 코드를 수정한다.
class Board
{
...
public int DestY { get; private set; }
public int DestX { get; private set; }
...
public void InitializeBoard(int size, Player player)
{
...
DestY = Size - 2;
DestX = Size - 2;
...
}
public void Render()
{
...
for (int y = 0; y < Size; y++)
{
for (int x = 0; x < Size; x++)
{
...
else if (y == DestY && x == DestX)
Console.ForegroundColor = ConsoleColor.Yellow;
...
}
}
}
}
이제는 Board에 목적지 정보가 있으니 Player 쪽에서 목적지 정보를 받아올 필요가 없어졌다.
public void InitializePlayer(int posY, int posX, Board board)
{
PosY = posY;
PosX = posX;
_board = board;
}
BFS 길찾기 알고리즘
인접 행렬 또는 인접 리스트 없이 타일 정보만 이용해서 가상의 그래프를 그려낼 수 있고 BFS 길 찾기 알고리즘을 적용할 수 있다. 하나의 타일을 노드라고 생각하고 상하좌우 바닥(노드)이 Empty라면 연결된 노드, Wall이라면 연결되지 않은 노드라고 판단할 수 있다.
BFS 코드를 작성하기 전에 미로 상의 X, Y좌표를 담을 Pos클래스를 정의했다.
class Pos
{
public int Y;
public int X;
public Pos(int y, int x) { Y = y; X = x; }
}
※ BFS 코드 ※
여느 BFS 코드와 유사하다. 주목할 포인트는parent와path를 정의해서 찾아왔던 길을 기록하는 코드이다.
List<Pos> path = new List<Pos>();
...
BFS();
...
private void BFS()
{
int[] dirY = new int[] { -1, 0, 1, 0 };
int[] dirX = new int[] { 0, -1, 0, 1 };
bool[,] found = new bool[_board.Size, _board.Size];
Pos[,] parent = new Pos[_board.Size, _board.Size];
Queue<Pos> q = new Queue<Pos>();
q.Enqueue(new Pos(PosY, PosX));
found[PosY, PosX] = true;
parent[PosY, PosX] = new Pos(PosY, PosX);
while(q.Count > 0)
{
Pos pos = q.Dequeue();
int nowY = pos.Y;
int nowX = pos.X;
for (int i = 0; i < 4; i++)
{
int nextY = nowY + dirY[i];
int nextX = nowX + dirX[i];
if (nextX <= 0 || nextX >= _board.Size || nextY <= 0 || nextY >= _board.Size)
continue;
if (_board.Tile[nextY, nextX] == Board.TileType.Wall)
continue;
if (found[nextY, nextX])
continue;
q.Enqueue(new Pos(nextY, nextX));
found[nextY, nextX] = true;
parent[nextY, nextX] = new Pos(nowY, nowX);
}
}
CalcPathFromParent(parent);
}
private void CalcPathFromParent(Pos[,] parent)
{
int y = _board.DestY;
int x = _board.DestX;
while (parent[y, x].Y != y || parent[y, x].X != x)
{
path.Add(new Pos(y, x));
Pos pos = parent[y, x];
y = pos.Y;
x = pos.X;
}
path.Add(new Pos(y, x));
path.Reverse();
}
BFS를 통해 path 정보를 채웠으니 Player가 자신의 위치를 갱신할 수 있도록 코드를 수정한다.
const int MOVE_TICK = 100;
private int _sumTick = 0;
int _index = 0;
public void Update(int deltaTick)
{
if (_index >= path.Count)
return;
_sumTick += deltaTick;
if (_sumTick >= MOVE_TICK)
{
_sumTick = 0;
PosY = path[_index].Y;
PosX = path[_index].X;
_index++;
}
}
현업 3D 게임엔진 프로그래머가 전수해드리는 고농축 고퀄리티의 과외를 만나 보실 수 있습니다
[ 이력 ]
넥슨, NHN, 넷마블 다수 동종/타종 근무 경험 및 다년간 현업 개발자
3D 게임 엔진 프로그래머/ 3D,2D 게임/ 언리얼 엔진/ 엔진 프로그래머/ 메인 PC 게임 개발 / 모바일 게임/엔진 개발
미들웨어(엔진)/ 일반 프로그램 프로젝트 제작
고차원 수학/ 물리등의 알고리즘과 관련된 특수 프로그램 제작
게임업계 대기업 넥슨,넷마블, NC 외 P사, 중견 B사 등등의 기업에 합격시킨 노하우
다수, 다양한 분들에 대한 다수의 과외 경험으로 축적된 노하우 보유
기타 일반 프로젝트 경험
과외 등록 완료, 남, 성범죄 "완전 무(無)"!!
[ 수강하셨던 분들 ]
동종 현업 3N 사 포함/비 동종업계 현업 프로그래머 분들 다수 수강
해외 글로벌 대기업 E* 사, 국내 일반/게임업계 대기업 현업 프로그래머, TA, 아티스트, 기획자
국내 현업 게임 및 비게임 업계 종사자 대기업, 중견, 벤처 회사원과 기업가, 사업가(CEO)
대학생(취준생), 서울대, 고려대, 일본게이오대 등등 SKY 포함 상위 10% 이상 대학생, 그 외 학교 및 유학생 하위권 에서도 포기하지 않고 노력했을때 대기업에 간 선례들이 많이 있습니다, 포기하지 마세요!
전공자/컴퓨터 관련 전공자가 아니지만 게임이나 프로그램 쪽으로 진로를 희망하시는 분들 (비전공자 일지라도 많은 상당수의 분들이 원하는 성과를 이루고 가셨습니다)
전문 프로그래머로 진로를 정하시거나 또는 희망하시는 분들
프로그램을 혼자 하기엔 막연하여 그룹(단체) 배워보고자 하시는 분들
초심자, 프로그램 배워보려 했지만 진입 장벽 때문에 포기하신 분들
[ 과외 대상 ]
처음부터 끝까지 완성도 있는 프로그램 체계를 제대로 쌓고싶으신 분
견고하면서 제대로 된 스킬을 배우고 싶으신 분
자료를 찾아봐도 정확한 답을 찾기 어려웠던 분
실력을 더 쌓아가고 싶은 현업 프로그래머
다른 교육원에서 실질적인 배움을 채워주지 못한 부분에 갈증을 느끼시는 분 또는 취준생
취직/이직/현업에서 사용되는 3D/2D 게임 프로그래밍의 스킬을 쌓고 싶은 분
만드는 것에만 열중해 설계를 보지 못하는 분이나 프로젝트 규모가 커질 수록 문제를 명확하게 해결하는데 한계를 느끼신 분
박사/석사/전공생/비전공생/유학생/컴퓨터 전공 관련 또는 프로그래밍에 관심이 있는 분
3D 그래픽스 수학을 배우고자 하는 분(기초부터 현업 수준까지)
수학적 개념이 어느 정도 있고 응용은 하지만 원하는 결과를 잘 못 만들어내는 분
일정 수준의 수학 실력은 되긴 하나 좀 더 심도 있는 프로그램적 수학 스킬을 원하시는 분
초심자 or 기초가 부족하거나 또는 약간의 기초는 있지만 어떻게 공부해야 할지 막연하신 분
[수업의 목표]
학원 같은 대규모 기업체가 아니기 때문에 개인 강의 여건상 많은 분들을 가르치진 못하지만 포트폴리오 꼼수가 아닌 확실한 것을 하나하나 이해될 때까지 알려드리려 노력하고 수강생분들의 앞길에 실질적으로 도움이 될 수 있는 방안을 깊이 있게 고민하고 해결책을 드리려 합니다
진도만을 위한 도서 위주의 수업 또는 깊은 이해가 동반되지 않는 방식 즉 겉핥기로는 진정한 프로그래머 또는 게임/엔진 프로그래머의 문턱에 조차 도달할 수 없습니다는 점을 기억해주시면 될 것 같습니다
[이직/신입 취직하신 분들]
3DMP 에서 배워 이직/합격/수강하신 분들의 주요 회사들입니다
EA 코리아,넥슨 코리아,NC,넷마블,넷게임즈 크래프톤,펍지,펄어비스,블루홀 스마일게이트,NHN, 기타 등등 ..
[ 통합 진행 과목 ]
방향에 따른 과목들은 상담을 통해 설정됩니다 추가 과목에 대한 추가 비용은 들지 않으며 희망하시는 과목들을 선정해서 들으실 수 있습니다
일반 수학, 2D수학 미들웨어,STL 기반 자료구조와 알고리즘,
최적화 알고리즘,설계-디자인(Design Pattern)
C언어/C++,C++ 11~, 현업디버깅 스킬 , 시스템 베이스
기초수학, 현업 3D 실전 수학, 수학적용을 위한 실전 코드베이스 작업
DirectX9 / DX12, DX를 통한 실전 수학 활용 병행
멀티쓰레드 프로그래밍,기초 물리(Physics), 캐릭터, 지형 엔진 & Tools,
Graphics : 3D 애니메이션, Shader, DX shader(HLSL), Unity shader
게임 엔진 :Unreal 4, Unity3D [주의] 학교 과제 의뢰는 받지 않습니다(스스로 혼자 만들어 내는것을 목표로 합니다)
[ 과외 기본 방향성 : 개인 맞춤형 최적화 설정]
수업은 수강자분의 현재 상태에 맞는 최적화된 맞춤 방식으로 진행되는 것을 원칙으로 하며 모든 과목은
최종적으로는 혼자만의 생각으로 수학/프로그램을 만들어 나가는 것을 진행 시 가장 우선적인 목표 진행합니다
이해가 빠른 편인지 느린편인지 사전에 말씀해주시면 더 욱 좋습니다
과목은 위에 나열한 과목들이 있지만 원하는 과목 또는 수준에 따라 먼저 시작하게 되는 과목이 변경되니 과목 란에서 이런 과목이 있다는 것만 참고하시면 됩니다
철저히 수강생 맞춤형으로 진행됩니다(수강자 분의 수준이 고려된 최적의 선에서 시작합니다) 상담을 통하여수강자의 현재 실력 기준으로부터 부족한 부분은 채워 나가고 수강생의 목표에 따라 추가해야 할 부분은 상담을 통해 얘기를 나누고 협의하에 방향을 함께 정합니다
수업은 원격으로 진행되며 수강자가 본인의 컴퓨터에서 직접 코드를 작성하면서 진행됩니다(이론과 코드가 병행)
과외 기본 목표 : 혼자만의 힘으로 희망하는 수준까지의 프로그램 실력을 쌓는 것을 기본 목표로 합니다
[ 과외 안내 ]
예약 대기: 예약 신청 시 공석이 생길 경우 우선적으로 연락을 드리고 있습니다 신청자가 많은 경우 대기 기간이 발생할 수 있습니다
진행 방식 : 개인 과외 1:1 진행 방식 / 1:N 방식
1 Section 기준 = 4주/4회, 추가 섹션은 및 진행은 별도 문의주시면 답변해드립니다
1 회당(1 섹션) 시간 : 1:00, 섹션당 추가에 따른 누적 할인 적용
수강 기간 : 한 달 단위로 수강, 수강생이 희망하는 달까지 진행되며 한달 단위 결제방식입니다
과외 장소/방식: 코로나로 인하여 온라인으로만(원격, 카메라 Off ) 진행하고 있습니다 온라인은 오프라인과 거의 동일하게 진행되며 다년간 온라인과 오프라인의 노하우로 둘 방식에는 큰 차이가 없다고 보시면 됩니다 해외에 거주하신 분들의 경우 네트워크 속도에 유의해 주시기 바랍니다(사전 네트워크 테스트 가능)
납부 방식 : 한 달 단위, 해외에 계신 분들에 한하여페이팔로 결제 가능
그룹 과외 :그룹(2인 이상은) 별도 문의 , 추가 할인 적용
[수강 특전] : 3DMP 네트워크
현업 게임 프로그래머들과 함께 지속적인 '3DMP 네트워크 데이' 에서 정보 교류활동의 기회
