보관함

언리얼에서 오브젝트가 추가 될때 호출 되는 함수는 PostInitProperties()

프로퍼티가 수정될때 호출되는 함수는 PostEditChangeProperties()

위 두함수는 AMyActor의 부모클래스인 AActor에서 상속 받은 함수이기때문에 부모클래스의 함수를 자식클래스에서 덮어쓴다는 의미로 virtual override 키워드를 함께 사용해줘야합니다. 컨트롤 + Dot(.)을 누를 시 cpp에 함수를 정의해줍니다.

Super::PostInitProperties()

Super 클래스는 클래스가 상속받은 부모 클래스에 있는 기본 프로퍼티나 함수를 가져오는데 사용되는 키워드입니다.

이런작업을 해주는 이유는 전에 부터 하는 작업을 다시하도록 만든것입니다. 함수 또한 블루프린터에서 볼 수 있도록 설정하려면 UFUNCTION을 이용한다.

(BlueprintCallable 라고 설정하고 Category = "~"를 반드시 적어줘야합니다.

블루프린터에서 디자이너와 협력 시 디자이너가 만들어논걸 기능 구현을 하는 방법은 두가지가 있습니다.

첫 번째로 블루프린트 맨터블 방식 헤더에서만 함수선언 UFUNCTION에서 BlueprintImplementable 를 사용합니다. 요기서 알 수 있듯이 언리얼은 자체 함수의 기능이 관련있는건 앞에 이름이 붙는거 같습니다. Event를 설정 후 함수 형식의 기본 이름 반환형만 설정 후 블루프린터로 갑니다. (cpp엔 정의 안합니다.) 그리고 블루프린터에서 오른쪽 클릭 자신이 정한 카테고리에 있는 함수 이름을 생성해 블루프린터에서 기능을 구현합니다. 디자이너가 블루프린터로 만든 기능을 프로그래머가 cpp파일로 호출 하는 방식, 블루프린터에서 기능을 만들어놓지 않으면 빈 함수를 호출하는 방식으로 동작하게 됩니다.

두 번째로 블루프린트네이티브 이벤트 지정자는 디자이너가 블루프린터로 기능을 만들 수 있게하면서 만약 디자이너가 블루프린터에서 기능을 구현하지 않으면 동작할 기본 기능을 프로그래머가 cpp로 만들 수 있게 됩니다. 

BlueprintNativeEvent를 사용합니다. 그리고 virtual void 함수이름_Implementation 가상 함수를 구현해주고 cpp에 기본 기능을 구현한 함수를 정의해줍니다. 이런식으로 하면 블루프린트내에서 구현하지 않아도 cpp에 구현해논 함수가 작동합니다.

하지만 기본 함수와 블루프린터에서 작동하고 하고 있는 함수 둘 다 호출하고 싶을땐 함수이벤트 생성 후 함수 이벤트에 오른쪽 클릭 부모 함수의 호출 추가를 누르면 부모:함수 이름을 가진 노드가 생성됩니다. 그리고 호출 순서를 생각하여 하고 싶은대로 이어주면 됩니다. 이런식으로 협업의 용이합니다.

UPROPERTY() 매크로

UPROPERTY()
	int32 IntVar;

이렇게 변수의 기본형으로 사용합니다. UPROPERTY 매크로의 역할은 프로퍼티가 있음을 알리고 연결되었을때 어떻게 동작할지 지정하기 위한 것입니다.

그리고 보통 short , int , long을 알고 있는데 이런 타입은 플랫폼마다 길이가 달라질 수 있기 때문에 언리얼엔진에서는 길이가 고정되있는 타입으로 int8, int16, int32, int64 int 뒤 숫자는 정수를 표현하는데 몇개의 비트를 사용할것인지를 의미합니다.

int8 - 127 ~ -128,

int16 - 32,767 ~ -32,768

int32 - 214,648,647 ~ -214,648,648

int64 - 9,223,372,036,854,775,807 ~ -9,223,372,036,854,775,808

까지 표현가능합니다. 만약 해당 변수가 숫자를 음수로 표현할 필요가 없다면 int 대신 uint 등으로 사용 가능합니다. 음수의 범위를 양수의 범위로 대체되어 2배만큼 표현이 가능해집니다.

uint8 - 0 ~ 255

uint16 - 0 ~ 65,535

uint32 - 0 ~ 4,294,967,295

uint64 - 0 ~ 18,446,744,073,709,551,615

까지 표현할 수 있습니다. 이렇게 정수타입을 사용할때는 크기를 잘 생각해서 어느타입을 사용할지 결정하면 됩니다.

만약 int8 변수에 127에서 +1 할시 -128 오버플로우 (Overflow)

-128에서 -1을 해버리면 127 언더플로우(Underflow) 라고 부릅니다.

게임에서 돈을 모았는데 어느순간 0이나 -가 되어버리는 문제등이 발생하게 됩니다. 그게 바로 위 문제때문에 발생합니다. 

위 문제를 없애기 위해 uint64를 사용하게 된다면 메모리 낭비가 심해집니다. 최적화를 위해 적절한 범위를 사용하는게 관건인것 같습니다.

만약 그 범위를 가늠할수 없다면 예외 처리를 통해서 그 숫자 범위를 벗어나지 못하도록 하는것이 좋습니다. 예를 들어 돈을 소지한도를 설정해논 사례인것 같습니다.

그다음은 float 부동소수점 입니다. float, double 이 있는데 float 32 비트 double은 64 비트의 크기를 가지고 float은 5자리 소숫점 정밀도, double 은 두배인 10자리의 소숫점 정밀도를 가집니다.

다음은 문자열 입니다. c++에선 std string을 사용하고 언리얼 cpp에서는 필요에 따라서 여러가지 클래스로 문자열을 제공합니다. 가장 기본 타입은 FString 변수이름; 타입입니다. 저장되는 글자의 숫자에 따라서 변수의 길이가 자동으로 달라지는 타입으로 기본 Cpp의 std string 과 유사하게 동작합니다. 하지만 보통 string에선 " "안에 바로 상소 문자열을 적어서 바로 넣지만 FString에서는 텍스트 매크로를 사용해야합니다. 이외에도 현지화 텍스트를 위해서 사용하는 FTest, 자주 사용되는 문자열을 식별자로 지정해서 문자열을 비교할때 소모되는 메모리와 CPU 시간을 절약하는데 쓰이는 FName, 플랫폼마다 다를 수 있는 문자열 세트와 상관없이 문자열을 저장하는 용도로 사용되는 TCHAR가 있습니다.

FString을 제외한 타입은 나중에 필요 시 다룬다고 합니다. 그리고 bool 이 있습니다.

그리고 public , private , protected 공개 범위를 적용 시 변수 앞이 아닌

public: (접근 지정자를 지정하여 작성합니다. 다음 접근 지정자를 정하기 전까지 public이 됩니다.)

하지만 유니티처럼 퍼블릭 설정을 해도 디테일 패널에서 수정 및 볼 수 있지 않습니다. 이때 UPROPERRTY를 사용합니다.

  UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Damage")
  	int32 TotalDamage;
  UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Transient, Category = "Damage")
  	float DamagePerSecond;

EditAnywhere - 양쪽 모두의 프로퍼티 창에서 편집 할 수 있음을 의미합니다.

VisibleAnywhere - 프로퍼티 창에서 보이지만 편집을 불가하게 합니다.

BlueprintReadWrite - 블루프린트에서 읽기, 쓰기를 모두 가능하다는 뜻입니다.

BlueprintReadOnly - 블루프린트에서 읽기만 가능

Transient - 해당 프로퍼티가 휘발성 프로퍼티로 저장되지 않음을 의미합니다.

Category = " " - 블루프린트 편집 툴, 디테일 패널에서 이 프로퍼티를 데미지라는 카테고리로 묶어서 보여준다는 뜻입니다. 밀접한 관계를 가진 프로퍼티들은 같은 카테고리로 묶어줄 시 작업할때 빠르게 찾을 수 있습니다.

MyActor 생성자 소스 파일에서 프로퍼티를 초기화 해줍니다 두가지 방법이 있습니다.

AMyActor::AMyActor() 
: TotalDamage(200), DamageTimeInSeconds(1.0f), CharacterName(TEXT("탄산수")), bAttackable(true)
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	TotalDamage = 200;
	DamageTimeInSeconds = 1.0f;
	CharacterName = TEXT("레몬");
	bAttackable = true;
}

두가지 방법 중 선호하는 방법을 사용하면 됩니다.

스크립트 한글이 깨져서 컴파일 오류가 뜹니다 이경우 (1) 스크립트 한글 깨짐 문제 해결하기 | 언리얼 4 - YouTube

영상을 보고 해결하면 됩니다.

입문 Unreal 4 강의를 따라 작성됐습니다.

클래스와 이름이름과 같은 이름을 가진 생성자 Awake

This 객체가 생성될때 호출되는 함수이며 주로 생성된 액터의 변수의 기본값을 설정해주는데 사용됩니다.

BeginPlay 함수

This 객체가 월드에 스폰되었을때 한번 실행되는 함수로 게임 플레이어 로직을 초기화하는데 사용

Tick 함수

매 프레임마다 호출되는 함수, Tick 함수에 DeltTime 매개 변수는 전에 호출된 이후로 얼마나 시간이 경과한 뒤에 다시 Tick가 호출되었는지에 대한 시간을 전달받을 수 있습니다. 주로 게임의 로직을 구현하는데 사용됩니다. 하지만 매 프레임마다 호출되는 Tick 함수가 불필요한 경우 지워 포퍼먼스를 상승시킬 수 있습니다. 방법은 헤더 파일과 소스 파일에서 Tick 함수를 제거 소스 파일 생성자에서 PrimaryActorTick.bCanEverTck = true; 제거해주면 됩니다. 앞에서 지운 생성자에 있는 명령어는 액터가 Tick 함수를 매프레임마다 호출하도록 설정하는 코드입니다.

// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "CameraDirector.generated.h"

UCLASS()
class KIMUNREAL_API ACameraDirector : public AActor
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	ACameraDirector();

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;
};

// Fill out your copyright notice in the Description page of Project Settings.


#include "CameraDirector.h"
#include <Kismet/GameplayStatics.h>

// Sets default values
ACameraDirector::ACameraDirector()
{
	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

}

// Called when the game starts or when spawned
void ACameraDirector::BeginPlay()
{
	Super::BeginPlay();
}

// Called every frame
void ACameraDirector::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);
}

액터 Cpp 클래스 생성 시 기본 형태입니다.

UE_LOG(LogTemp, Log, TEXT("")); 언리얼 엔진에서 로그를 남기는 함수

로그를 보는 방법은 창 -> 개발자 툴 -> 출력 로그 창을 켜줘야합니다.

7강입니다 constructor 01

생성자와 소멸자에 대해 설명합니다.

sturct 를 클래스로 변경했습니다. class로 변환 시 안에 모든 데이터 멤버들을 public으로 전환해줘야합니다. 이렇게 변환 시 바꾸기 전 sturct와 유사하게 변환됩니다. 

#include <iostream>



class KPeople 
{
public:
	int age; // 데이터 멤버(date member)
	char name[12];

	void PrintPeople() // 멤버 함수 (member function)
	{
		printf("%s : %i\r\n", name, age);
	}
	void SetAge(int age_) 
	{
		age = age_;
	}
	void SetName(const char* name_)
	{
		strcpy_s(name, name_);
	}
};

void main() 
{
	KPeople a;
	a.SetAge(48);
	a.SetName("John");
	a.PrintPeople();
}

클래스를 설계하다 보면 객체를 만들자 마자 초기화를 해 줄 필요가 있습니다. 위 코드에선 age, name을 초기화 할 필요가 있다고 과정해보겠습니다. 초기화하지 않은 변수를 접근하는걸 위험하기 떄문입니다.

그리고 어떤 이유에서 객체를 파기하기전에 마무리 해줄 필요가 있다면 멤버 함수로 정의 할 수 있습니다.

class KPeople 
{
public:
	int age; // 데이터 멤버(date member)
	char name[12];

	
	void Initialize() 
	{
		age = 0;
		name[0] = 0;
	}

	void Finalize() 
	{
		// 마지막에 해체 전 실행될 멤버 함수
	}

	void PrintPeople() // 멤버 함수 (member function)
	{
		printf("%s : %i\r\n", name, age);
	}
	void SetAge(int age_) 
	{
		age = age_;
	}
	void SetName(const char* name_)
	{
		strcpy_s(name, name_);
	}
};

위와 같이 멤버 함수의 Initialize와 Finalize를 만들어주고 사용하게 되면 아래와 같습니다.

void main() 
{
	KPeople a;
	a.Initialize();

	a.SetAge(48);
	a.SetName("John");
	a.PrintPeople();
	
	a.Finalize();
}

따로 메인에서 초기화를 안할 시 쓰레기값이 들어가 잘못된 결과값이 날 올 수 있기때문에 외에도 여러 상황에서도 사용 가능합니다. 이와 같이 객체를 만들자 마자 초기화하는 함수를 생성자라고합니다. 반드시 자기 자신과 똑같은 이름을 가져야합니다. 객체를 만들자마자 자동으로 호출되기때문에 함수 호출 이름을 명시 할 방법이 없습니다. 함수가 종료되기전에 Finalize도 자동으로 명시 할 방법 또한 없습니다. 그래서 특별한 이름을 가져야합니다.

그래서 C++에서는 객체를 만들자 마자 자동으로 호출되는 초기화 함수를 생성자라 합니다.

클래스의 생성자를 정의하는 방법은 아래와 같습니다.

KPeople() //constructor
{
  age = 0;
  name[0] = 0;
  printf("constructor()\r\n");
}

소멸자 함수는 특별한 문법을 따라줘여합니다. 그리고 소멸자는 객체가 파괴되기 바로 전에 호출되는 함수입니다.

~KPeople() //destructor
{
	printf("constructor()\r\n");
}

이렇게 하는 경우 이제는 자동으로 호출되므로 따로 생성자, 소멸자를 만들고 main에 올릴 필요 없습니다.

void main() 
{
	KPeople a;
	a.SetAge(48);
	a.SetName("John");
	a.PrintPeople();
}

이제 KPeople을 동적할당 해보겠습니다.

	KPeople* p;
	p = (KPeople*)malloc(sizeof(KPeople));
    
	free(p);

malloc이 리턴하는 값은 보이드 포인터이기 때문에 캐스팅을 해줘야합니다. (KPeople*) 그리고 사이즈는 KPeople만큼 필요하므로 KPeople을 넣어줍니다. 그리고 메모리 해제 또한 해줘야합니다. 이렇게 될 시 이제 p를 통해서 접근이 가능하게됩니다.

요기서 빌드 시 쓰레기값이 나옵니다. 생성자에서 초기화를 해줬지만 쓰레기 값이 나오는 이유는 메모리 동적 할당 시 생성자를 자동 호출해주지 않습니다. 그래서 p를 이용해서 생성자를 호출해주는 부분을 직접 작성해줘야합니다. 소멸자도 마찬가지 입니다.

void main() 
{
	KPeople* p;
	p = (KPeople*)malloc(sizeof(KPeople));
	p->KPeople::KPeople();

	p->~KPeople();
	free(p);
}

KPeople만 입력 시 클래스 이름과 같아 모호함이 발생하므로 KPeople에 생성자를 호출한다고 명시해줍니다. 소멸자 경우 ~가 붙어있어 상관없습니다.

하지만 전에도 말했듯이 C++에선 new와 delete를 사용합니다.

	KPeople* p;
	p = (KPeople*)operator new (sizeof(KPeople)); // new 함수 ( new function)
	p->KPeople::KPeople();

	p->~KPeople();
	operator delete(p);

operator new 또한 보이스 포인터이므로 (KPeople*)로 캐스팅 해줍니다. operator new 경우 전역함수라 생각하면됩니다. operator new를 함수 이름이라고 생각하는게 나중에 헷갈리지 않는다고 합니다. 

하지만 이또한 생성자를 따로 호출해줘야합니다. 하지만 C++ 설계자들이 동적으로 할당 하고 자동으로 생성자를 호출 하도록 operator new와 생성자를 호출하도록 new expression을 만들었습니다 .

	p = new KPeople;
    
	delete p;

이것의 의미는 동적으로 KPeople만큼 메모리에 할당하고 자동으로 생성자 자동으로 호출하라는 뜻입니다.

소멸자 경우도 마찬가지 입니다. p의 경우는 KPeople 포인터입니다.

하지만 그럼 operator new는 필요없는거 아니냐 할 수 있지만 new expression은 오버로딩이 불가합니다 그래서 new의 오버로딩이 필요한 경우 operatorn new로 오버로딩을 해야합니다. 하지만 동적으로 메모리를 할당할 일이 있다면 new expression, delete expression을 사용하면 됩니다.

8강입니다.

 생성자의 파라미터가 들어갈 시 () 안에 들어갑니다. 없을 시 생략해도됩니다. 있어도 생략안하고 적어도 작동합니다.

p = new KPeople();

이런 식으로 처리 가능합니다.

p = new KPeople[3];

연속적으로 메모리 할당이 가능합니다. 뜻은 KPeople의 크기의 메모리를 3개를 할당한것입니다. new 에 []를 사용 시 delete[] p 와 같이 딜리트에도 표시해줘야합니다. 물론 3개를 만들기때문에 생성자 3번 소멸자 3번이 작동합니다.

그리고 접근 시엔 아래와 같이 접근 가능합니다. 0 , 1, 2 등 직접적인 접근이기 때문에 포인터가 아닌 객체가 되므로 . 을 사용합니다.

p[0].PrintPeople();
p[1].PrintPeople();
p[2].PrintPeople();

그리고 오버로딩을 생성자를 오버로딩 할 수 있습니다.

class KPeople 
{
public:
	int age; // 데이터 멤버(date member)
	char name[12];

	
	KPeople() //constructor
	{
		age = 0;
		name[0] = 0;
		printf("constructor()\r\n");
	}
	KPeople(const char* name_) // overloading
	{
		age = 0;
		strcpy(name, name_);
		printf("constructor(char*)\r\n");
	}

	~KPeople() //destructor
	{
		printf("destructor()\r\n");
	}

	void PrintPeople() // 멤버 함수 (member function)
	{
		printf("%s : %i\r\n", name, age);
	}
	void SetAge(int age_) 
	{
		age = age_;
	}
	void SetName(const char* name_)
	{
		strcpy_s(name, name_);
	}
};

// 1번째 생성자
KPeople p;

// 2번째 생성자
KPeople p("John");
KPeople p = "John"; // 암시적인 생성자 호출 implicit construton call

void Test( KPeople p )
{
	p.PrintPeople();
}

void main()
{
	KPeople p = "John";
	Test("Mike");
}

암시적 생성자 호출을 할 시 이런식으로 사용 가능하지만 이렇게 사용 할 시 문제가 될 수 있습니다. 그래서 생성자 호출을 할 때 명시적인 호출만 받겠다라고 지정할 수 있습니다.

explicit KPeople(const char* name_)
{
  age = 0;
  strcpy(name, name_);
  printf("constructor(char*)\r\n");
}

생성자에 explicit을 앞에 붙여주면 됩니다. 이렇게 될 시 암시적 호출을 할 시 컴파일 에러를 발생 시킵니다. 이렇게 바꾸고 위위 코드에서 컴파일 할 시 오류를 발생하는걸 볼 수 있습니다. 그래서 사용을 하려면 아래와 같이 수정합니다.

void main()
{
	KPeople p ("John"); // implicit construction call
	
    	KPeople temp = KPeople("Mike");
	Test(KPeople("Mike")); //temporary object
}

KPeople temp에 생성자로 KPeople("Mike")를 전달 시키는 겁니다.

Test 함수에 직접 단독으로 쓰인 경우는 KPeople("Mike")를 KPeople타입에 객체 파라미터로 "Mike"를 전달하고 임시 스택에 만들어지는 임시 객체를 생성한다는 뜻입니다. 그래서 이문장은 생성자를 호출합니다. 

근데 이런식으로 코드를 짠 후 컴파일 해서 결과를 보면 생성자 3번 소멸자가 4번이 호출되는 현상이 생깁니다.

9강입니다.

위와 같이 할 시 생성자가 p , temp, KPeople , Test 에서의 KPeople p 에서 생성자가 총 4번 생성 소멸자가 똑같이 4번 생성되어야하지만 생성자가 3번만 생성됩니다. 왜 그런지 메모리를 그려보겠습니다.

정리도 할겸 천천히 메모리를 그려가며 내려가겠습니다. 항상 주소는 임의에 값을 적어논겁니다.

class KPeople 
{
public:
	int age; // 데이터 멤버(date member)
	char name[12];
    
void main() 
{
	KPeople p("John");

메인에 들어왔을때 p가 할당됩니다. p는 KPeople 타입으로 int 4바이트 char[12] 12바이트 총 16바이트를 차지합니다. name의 시작주소는 5004 +4된 값이 됩니다. 5000+15까지 차지하는 16바이트의 크기의 메모리가 됩니다. 

	KPeople() //default constructor
	{
		age = 0;
		name[0] = 0;
		printf("constructor()\r\n");
	}
	explicit KPeople(const char* name_)
	{
		age = 0;
		strcpy(name, name_);
		printf("constructor(char*)\r\n");
	}

"John" 전달합니다. 그렇게되면 2번째 생성자가 호출되어서 name을 복사하고 age를 0으로 만듭니다.

이렇게 들어옵니다. 하지만 age랑 name이라는 값은 이곳에 표기되어있지 않습니다. 혼동을 피하기 위해서 지워줍니다. 그리고 이제 temp 객체를 만듭니다.

KPeople temp = KPeople("John");

Temp를 만들었습니다 . 다음 KPeople("Mike")를 임시로 호출합니다.

Test(KPeople("Mike")); //temporary object

이 객체는 어디로 만들어질지 모릅니다. 실제로 스택에 만들어질 확률이 높습니다. 주소와 이름이 없습니다. 그래서 temporary object 라 부릅니다.

이렇게 생성자가 총 3번 호출됐습니다. 임시로 만들어진 객체를 이제 Test에 전달됩니다.

void Test(KPeople p) 
{
	p.PrintPeople();
}

파라미터로 KPeople p를 메모리에 할당합니다. 요기서 생성자가 3번만 호출된 이유를 알 수 있습니다. Test 함수를 진행하며 KPeople p가 생성된게 아닌 임시객체로 생성된 ?를 그대로 복사한 형태여서 Test 함수에선 생성자를 호출하지 않습니다.

이렇게 Test 함수를 작동하면 출력하고 일을 끝낸 Test 함수를 메모리 해제하며 그전에 소멸자가 호출됩니다.

그리고 이제 main으로 돌아가 스택메모리에서 순서대로 메모리 해제 전에 소멸자가 호출됩니다. 그래서 총 4번 호출이 됩니다.

생성자와 소멸자가 쌍으로 안이루어질때 오류가 발생할 수 있습니다. 그럼 근본적인 문제인 객체가 복사가 되는 경우에 호출되는 특별한 생성자를 정의를 해줘야합니다. 이걸 copy constructor라고 합니다.

copy constructor는 객체가 복사되는 문법을 표현해주기 위해서 자기 자신의 타입에 레퍼런스(&)를 매개변수로 받습니다. 복사되는 시점에 다시 복사를 막기 위해서 입니다. 

KPeople(const KPeople& rhs) // copy constructor
	{
		printf("copy constructor()\r\n");
	}

문법 기억

class KPeople 
{
public:
	int age; // 데이터 멤버(date member)
	char name[12];

	
	KPeople() //default constructor
	{
		age = 0;
		name[0] = 0;
		printf("constructor()\r\n");
	}

	explicit KPeople(const char* name_)
	{
		age = 0;
		strcpy_s(name, name_);
		printf("constructor(char*)\r\n");
	}

	KPeople(const KPeople& rhs) // copy constructor
	{
		age = rhs.age;
		strcpy_s(name, rhs.name);
		printf("copy constructor()\r\n");
	}
	~KPeople() //destructor
	{
		printf("destructor()\r\n");
	}
};

void Test(KPeople p) 
{
	p.PrintPeople();
}

void main() 
{
	KPeople p("John"); // 암시적인 생성자 호출 implicit construton call
	KPeople temp = KPeople("John");
	Test(temp); //temporary object
}

오류 시 strcpy_s를 사용합니다. 요기서 주의 해야할 점은 이미 복사한 값을 호출 할 시 복사 생성자가 호출된다라는 점입니다.

Test(temp)로 변경 이유는 KPeople("Mike")를 작성 시 생성자 한번 복사 생성자 한번이 호출이 되는데 컴파일 최적화로 생성자 한번만 호출되어 복사생성자를 호출하지 않는 문제가 있어서 이미 복사된 값을 사용했습니다. 위 메모리를 그리며 정리한걸 봐도 ?를 Test로 복사한 형태라서 생성 후 복사 호출되는게 맞지만 최적화된것 같습니다. 

객체가 복사되는 시점과 생성되는 시점을 이해하면 좋습니다.

10강입니다. 

객체를 만드는 팩토리 함수를 만듭니다.

KPeople GetPeople()
{
	KPeople t;
	return t;
}
or
KPeople GetPeople()
{
	return KPeople("Mary"); //RVO
}


void main() 
{
	KPeople t;
	t = GetPeople();
	//Test(t); // temporary object
}

생성자가 2번 작동합니다. 하지만 복사생성자가 작동하지 않는건 아닙니다. class 내에서 private 처리해버리면 오류가 발생합니다. 이유는 RVO에 의해 스킵될뿐 복사생성자를 검사를 하지 않는게 아니기 때문입니다.

RVO는 컴파일 최적화 형식으로 생성자를 최소화 합니다.

C++ 강좌를 보면서 배운걸 정리합니다.

유니티 포트폴리오로는 C++ 회사에 지원하기 힘든 것 같아 언리얼 엔진4을 만져보기 위해 공부하는 중입니다.

포트폴리오로 만들기 위해서 어떤 방향으로 해야할지는 C++ 공부 후 검토해볼 생각입니다.

참고 강좌 : C++

struct 강좌는 총 3강입니다.

사용할 구조체 형태입니다.

struct People // type definition
{
	int age; // member variable
	char name[10];
}/*a*/; 

People 부분은 태그네임이라고 합니다. struct People이라는 타입으로 정의된 동시에 a라는 변수로 정의된 상태입니다. 구조체는 타입도 정의할 뿐만 아니라 변수도 정의할 수 있는 특별한 구조를 가지고 있습니다.

그리고 구조체로 타입을 정의 할때 변수를 정의 할 수 있지만 가독성을 위해 변수를 바로 선언하지 않고 이후 사용 할때 다시 변수로 선언하여 사용합니다.

구조체를 사용 시 

void main ()
{
    People a;
    a.age = 28;
    strcpy_s(a.name, "Hello");

    //strut People b; strut People이 타입 이름
    People b; // strut 생략가능

    b.age = 29;
    strcpy_s(b.name, "World");
}

strut에 경우 C에선 생략이 불가능합니다. strcpy_s에 경우 문자열을 복사하는 함수입니다. 

이렇게 작성 후 출력을 해보겠습니다.

void PrintPeople(People A) {
	printf("%s : %i\r\n", a.name, a.age);
}

PrintPeople(a);
PrintPeople(b);

결과 값

Hello : 28

World : 29

2강 정리입니다. 아래는 전에 코드를 정리했습니다.

struct People // type definition
{
	int age; // member variable
	char name[10];
};

void main()
{
	People a;
	People b;
	 
	a.age = 47;
	strcpy_s(a.name, "Hello");

	b.age = 48;
	strcpy_s(b.name, "World");

	PrintPeople(a);
 	PrintPeople(b);
}

구조체를 main의 스택 메모리를 그리면 아래 그림이 됩니다.

내부 단편화 - 표기된건 10바이트지만 윈도우에서 효율적인 메모리 관리를 위해 4바이트씩 끊어서 사용 
그래서 실제로 12바이트를 차지하고 마지막 2바이트가 비어있게 됩니다.

age 부분은 주소값이지만 편의를 위해 age로 표기했습니다.

실제로 위와 같은 구조를 가졌는지 테스트를 해보도록 하겠습니다.

	char *cp = (char*)&a;

캐스팅(형변환)을 한 이유는 &a의 시작 주소는 구조체의 시작 주소이므로 char포인터에 대입이 불가해서 캐스팅을 해줬습니다.

그리고 테스트를 위해 e를 출력해보겠습니다.

 위 그림 처럼 메모리를 그린게 맞다면 메모리 위치를 계산 시 +5를 할 시 e를 찾을 수 있습니다.

	printf("%c\r\n", cp[5]);

*(cp + 5) 브레킷연산자를 사용해 cp[5]로 출력하면 e가 나옵니다.

void main()
{
	People a;
	People b;
	 
	a.age = 27;
	strcpy_s(a.name, "Hello");
	char *cp = (char*)&a;
	printf("%c\r\n", cp[5]);

	b.age = 46;
	strcpy_s(b.name, "World");

	PrintPeople(a);
}

 이 상황에서 PrintPeople 함수를 호출 시 

PrintPeople 만큼의 메모리를 할당합니다.

메모리 몇번째인지는 함수호출이 일어나면서 중간에 메모리를 차지하므로 메모리 정확한 계산은 힘듭니다.

프린터피플의 스택프레임, 메인 스택 프레임을 나눠지며 메인에서 정의한 a 값이 프린트피플에서 할당한 A 공간으로 복사가 됩니다.

위와 같이 되므로 프린터피플에서 a.age의 값을 바꿔도 값은 변경되지 않습니다. 단순하게 복사한 값이기 때문입니다. 이렇게 함수 안에서 변경된 값은 함수 밖 값에 영향을 줄 수 없습니다. 이걸 함수에서 변경을 하기 위해선 포인터를 전달해야합니다.

3강 정리입니다.

void PrintPeople(People a) {
	printf("%s : %i\r\n", a.name, a.age);
	++a.age;
}

포인터를 사용하기전 테스트를 해봤습니다. 위 함수에 ++a.age를 추가합니다.

함수를 실행 시 PrintPeople 프레임 age에 +1이 늘어나지만 함수를 빠져나오는 PrintPeople 값이 팝되어서 main 값엔 영향이 없습니다.

a를 변경되지 않고 +1 계산된 값을 출력하고 싶은거면 맞지만 의도가 PrintPeople에서 계산값된 값을 main에 있는 age 값을 변경하고 싶으면 위와 같이 구조체를 전달해서는 바끼지 않습니다.

 ++a.age부분을 제거 후 다시 함수를 만듭니다.

void SetAge(People *A, int newAge) 
{
	(*A).age = newAge;
}

void main()
{
	SetAge( &a, a.age + 1 );
	PrintPeople(a);
}

필요한 부분만 적었습니다. a = 47입니다.

SetAge는 매개변수로 들어온 구조체(A).age를 newAge로 들어온 값으로 바꿔주는 역할을 합니다.

원래 함수는 값의 변경이 안되었는데 이번 함수의 다른 점은 변경을 필요로 한 값을 포인터로 넘겨주는겁니다. 메모리로 가서 직접 수정을 하는것이죠. 그리고 코드상에선 함수에게 줄 땐 & 주소연산자로 넘겨주고 함수에선 * 참조연산자로 받습니다. 이렇게 받으면 A는 현재 구조체 a를 복사한게아닌 구조체 a를 가르키는 포인터입니다. 그래서 (*A)를 사용했습니다. 이렇게 한 이유는 A는 더이상 구조체가 아니기 때문에 . 을 사용할 수 없습니다.

그래서 (*A) *A포인터가 가르키는 내용이 이게 구조체가 됩니다.

그리고 그값에 newAge를 대입하고 SetAge 함수를 빠져나옵니다. 그러면 SetAge부분이 스택에서 팝됩니다.

그리고 PrintPeople( a ) 부분이 실행되면서 함수가 호출됩니다. 이때 SetAge에 의해서 a.age는 47에서 48로 대입된 상태입니다. 48이 출력됩니다. 

메모리 또한 위에서 본것과 같이 a 구조체를 복사 스택에 push 출력 후 pop됩니다. 그리고 메인으로 돌아옵니다.

해보고 알 수 있는건 포인터로 전달 시 값에 대해서 변경 가능한 점과 포인터 경우 4바이트만 사용하여 메모리를 효율좋게 사용 할 수 있습니다.

void PrintPeople(People *A)
{
	printf("%s : %i\r\n", (*A).name, (*A).age);
}

// main 부분

	PrintPeople(&a);

구조체가 클 경우 단순 복사만 해도 메모리에 부담이 갑니다. 그래서 포인터로 메모리 최적화를 요 할 수 있습니다.

4강입니다.

구조체에 접근 하기 위해선 . 을 사용합니다. 하지만 구조체 포인터일 때는 People *A;에 A는 구조체가 아닌 포인터입니다. 그래서 *A가 가르키는 내용이 구조체입니다. 포인터는 가르키는것이기 때문에 연산전에는 포인터인채이고 연산자 우선 순위로 인해 먼저 계산이 안될 수 있으므로 (*A)로 표기해줍니다. 하지만 구조체를 메모리 효율을 위해 포인터를 사용하는 일이 많습니다. 매번 (*A)를 적긴 많이 번거롭습니다. 그래서 만들어진게 arrow operator 이며 dot operator 도 있습니다. 둘다 구조체를 위한 오버레이터입니다. dot operator는 구조체 자체가 선언되었을때 구조체 멤버로 접근합니다. arrow operator는 구조체 포인터로 선언되었을때 구조체 멤버로 접근합니다. 요기서 dot operator는 이때까지 써온 . 이란걸 알 수 있습니다. 그럼 arrow operator는 어떻게 사용하냐면 (*A).age ===> A -> age , * . 가 -> 로 바뀐 형식입니다.

void PrintPeople(People *A) {
	printf("%s : %i\r\n", A->name, A->age);
}

void SetAge(People *A, int newAge) 
{
	A->age = newAge;
}

arrow operator 로 수정한 함수 코드입니다.  - > 띄어씌기는 안됨

	People *b;
    
	b -> age = 48;
	strcpy_s(b -> name, "World");
    
   	PrintPeople(b);

이런식의 예제도 만들 수 있습니다. 구조체 변수로 생성하지 않고 포인터로 바로 생성 시는 dot이 아닌 arrow operator로 표기하며 포인터를 받는 함수의 경우 & 주소연산자를 사용하지말고 바로 포인터인 b를 넘겨주면 됩니다.

하지만 요기서 오류가 발생합니다. 이유는 그림으로 보면 이렇습니다.

b -> age = 48; 대입을 하는 순간 할당되어있지 않은 메모리를 사용해서 에러가 발생하는 상태입니다. 그래서 구조체가 가르킬 곳을 메모리를 할당한 다음 사용해줘야합니다.

void main()
{
	People *b;

	b = (People*)malloc(sizeof(People));

	b -> age = 48;
	strcpy_s(b -> name, "World");

	SetAge( b, b->age + 1 );
	PrintPeople(b);

	free(b);
}

malloc으로 가르키고 있는 곳에 메모리를 할당 해주고 sizeof 해서 사이즈를 정해줍니다. 하지만 이렇게 하면 void리턴이라서 오류가 납니다. malloc은 자동적으로 자료형을 정해주지 않아서 캐스팅을 해주어야합니다. 그래서 (People*) 를 적어줍니다.

코드를 보면 포인터는 따로 초기화 하지 않아 갈비지로 초기화 되어있습니다. 그리고 malloc으로 People (14) 사이즈 만큼 할당 됩니다. 위치는 알 수 없습니다. 임의로 정하겠습니다. malloc을 쓰고 나선 항상 free()를 사용해줍니다. 스택 메모리 처럼 그려놨지만 malloc이나 new 같은 동적 할당 메모리는 크기를 넓게 쓰기 위해 만들어진 곳이라서 heep 메모리에 저장됩니다. 

	b -> age = 48;
	strcpy_s(b -> name, "World");

위에 값을 기입하게 됩니다.  그 후에 

	SetAge( b, b->age + 1 );
	PrintPeople(b);

그 후에 함수를 실행하게 될 시 b 이미 포인터인 녀석을 넘겨주게 됩니다. 포인터 b를 넘겨주고 b를 구조체화하여 age 값에 +1 하여 함수를 계산합니다.

그후 출력합니다. 또한 밑에 함수도 정상 출력됩니다.

5강입니다.

메모리 계산 부분에서 실수를 해서 그림을 다시 고쳤습니다.

메모리 할당을 malloc로 하고 free로 했었는데 C++에선 같은 역할을 하지만 다른 형식이 있습니다. new 와 delete입니다. new는 메모리 할당을 하고 생산자 Constructro 라는 특수한 함수를 호출하고 delete는 메모리 해제를 하기 전에 파괴자라는 특별한 함수를 호출 합니다.

약간 다릅니다. 다른 부분은 나중에 따로 포스팅하겠습니다.

C++의 구조체 대해서 알아보겠습니다. C++ 구조체는 구조체 안에 함수를 가질 수 있습니다.

struct People // type definition
{
	int age; // member variable
	char name[10];  
	
	void PrintPeople(People *this_) { // member function
		printf("%s : %i\r\n", this_->name, this_->age);
	}

	void SetAge(People * this_, int newAge)
	{
		this_->age = newAge;
	}
};

특이한 형태입니다 구조체안에 들어간 함수는 이제 함수라고 하지 않고 멤버 함수라고 합니다.

호출 방법은 구조체에 접근 후 멤버함수를 호출하면됩니다.

6강입니다.

위와 같이 사용하게 될 시 위 함수를 보면 매개변수로 this_ 라는 포인터를 따로 main에서 받아 함수를 실행하는데 구조체에 멤버함수가 포함되어있는 구조체에서 멤버함수를 사용 시 구조체를 매개변수로 받을 일이 있을 시 매개변수가 아닌 함수내에서 this로 사용할 수 있습니다. 위와 같이 멤버함수는 항상 this 자기 자신을 항상 매개변수로 전달하는데 이걸 this 콜이라고 합니다.

	void PrintPeople()  // member function
	{
		printf("%s : %i\r\n", this->name, this->age);
	}

	void SetAge(int newAge)
	{
		this->age = newAge;
	}

멤버함수를 수정한 코드입니다. 그래서 PrintPeople은 전달하는 인자가 0개가 아닌 1개입니다.

그리고 5강을 통해 C의 함수와 C++의 함수가 다르는걸 알 수 있었습니다. 실제로 오버로딩때문에 C++에서 함수를 정의하면 함수이름 그대로 유지하지 않고 컴파일러가 변경합니다. 이걸 네임 맹글링 (Name Mangling)이라고 합니다. 그리고 멤버함수 역시 그냥 함수와 다릅니다. 자기 자신인 객체의 시작주소가 항상 전달됩니다. 그리고 멤버 함수의 경우 this라고 적어되지만 보통 this->를 생략해서 사용한다고 합니다.

	void PrintPeople()  // member function
	{
		printf("%s : %i\r\n", name, age);
	}

	void SetAge(int newAge)
	{
		age = newAge;
	}

void main()
{
	People *b;

	b = new People;

	b -> age = 48;
	// C 호출 관례 
	// C++ 호출 관례
	strcpy_s(b -> name, "World");
    
	// this 호출 관례
	b->SetAge( b->age + 1 );
	b->PrintPeople();

	delete b;
}

등 구별이 가능합니다. 함수 호출 관례에 대해선 나중에 따로 다루겠습니다.

그래서 이렇게 변수와 함수를 다 가진 구조체를 class라고 합니다. 그래서 struct를 class로 바꿔주면 됩니다. 하지만 접근 권한 문제가 발생하는데 아래와 같이 수정하면 됩니다.

class People // type definition
{
public:
	int age; // member variable
	char name[10];

	void PrintPeople()  // member function
	{
		printf("%s : %i\r\n", name, age);
	}

	void SetAge(int newAge)
	{
		age = newAge;
	}
};

링크드 리스트를 작성하기 위해서는 구조체 포인터를 자기자신의 멤버로 사용해야합니다.

그리고 구조체 멤버를 int 같은 타입이 아니라 특정한 몇 비트를 차지하도록 비트 필드 구조체를 만들수도 있습니다. 또 공용체는 구조체는 멤버를 위해서 모두가 메모리가 할당됩니다. 이런 멤버들 중에서는 가장 큰 멤버를 위해서만 메모리 할당이 됩니다. 하지만 이런것들은 나중에 따로 알아보고 지금은 문법에 집중하겠습니다.

코딩 테스트 치고 나오면서 C++에 대한 기초가 부족한거같아서 C++을 한번 완전 기초부터 다시 해보려고 합니다. 그리고 테스트 준비하면서 공부한걸 다시 정리해서 올릴 생각입니다. 공부도 먼저 책으로 공부 한다고 포스팅은 공부를 다하고 정리하면서 적습니다. 너무 포스팅을 미뤘네요.

C++ 기초전에 C 부분과 기초이론부분을 좀 더 공부하고 왔습니다.

계산적 사고 Computational Thinking

입력 - > 알고리즘 - > 출력 (와 같은 형식은 다 알고리즘이라고 할 수 있지만)

자신이 원하는 답을 도출해낼 수 있는 알고리즘을 만들어야합니다. 문제를 해결 할 수 있는 단계를 찾는 행위

컴퓨터의 작동원리

컴퓨터 (정보화기기) - 하드, 소프트

구성 요소(참고)

중앙 기억 장치 CPU

주 기억 장치 RAM - 전원을 끄면 데이터가 사라짐 'Random' - Aceess Memory (RAM) 임의 접근이 가능한 메모리

그래픽카드 GPU

보조기억장치 - HDD, SSD

컴퓨터를 켤때 일어나는 일 (자료)

운영체제가 해주는 일 (참고)

UNIX, Linux

iOS, 안드로이드

MacOS

Windows

등이 해주는 일 

시스템 프로그램 ( 바탕화면 보호기, 바꿔주는 기능 등)

원래 하드웨어를 어떻게 사용할 것인지 운영체제에 커널(핵심)에서 담당을 한다.

커널 - 운영체제에서 하드웨어를 관리, 중계해주는 핵심 역할

리소스 관리도 운영체제

이후 영상은 전에 한번 정리한적 있어서 스킵하겠습니다. (참고)

영상의 핵심은 CPU, 메모리가, 입출력이 분리가 되어있고 System bus에서 입출력을 받아 나눠주는 일을 한다.

그중 Address bus는 데이터값이 아닌 데이터값의 주소 포인터가 존재하는 이유입니다

CPU 구성 요소 (참고)

제어 장치 Control Unit , 산술 논리 장치(ALU) Arithmetic Logic Unit , 그리고 갖가지 레지스터로 구성 되어 있습니다.

레지스터 Registers는 CPU에 책상역할을 할 수 있다고 볼 수 있습니다. 여러 값을 올려놓는 역할을 합니다.

시각적으로 표현하면 이렇습니다.

포인터는 정확히 주소 값을 가르키는 것입니다. 메모리 값이 아닌 이점을 유의해야합니다.

CPU가 작동하는 원리는 영상에 잘 설명되어있지만 한번 제가 따로 순서를 적은걸 말로 풀어보겠습니다.

1. 프로그램 카운터에 주소값이 들어옵니다. (시작점) 5. 다음 카운터 주소값이 들어옵니다.

2. 메모리 주소 레지스터로 주소값을 넘겨주고 3. 메모리 데이터 레지스터에 주소에 입력되어 있는 값이 들어옵니다.

4. 값이 명령어 일 시 명령어 레지스터로 들어갑니다. 6. 명령어 레지스터에 있는 값이 제어장치로 들어갑니다.

7. 디코드를 실행해서 명령어를 해독해서 실행합니다. (주소 10에 있는 주소를 로드해라) 8. 메모리 주소 레지스터에 10을 넣어줍니다. 9. 3을 메모리 데이터로 가져옵니다.  10. 연산에 사용되는 값은 어큐뮬레이터에 저장된다. 산술 연산 장치를 보조해주는 레지스터 11. 다음 카운터 주소값을 실행합니다. ( 명령이 끝날 때까지 반복하며 명령어를 실행해서 산술 논리 장치에 넣어줍니다. ALU에서 계산된 값을 102 주소에 명령에 따라 12주소에 저장해서 끝납니다.

정보의 기본 단위 Bit 비트

바이트 ( 8개의 비트 ) 메모리 주소의 기본 단위

16, 32 비트 CPU가 데이터를 다루는 기본 단위 - word 워드 - 레지스터의 크기 (고정은 아님)

While문

~scanf가 가능해서 사용해봤습니다.

A+B - 5

    int a,b;
    while(~scanf("%d %d", &a,&b)){
        if(a+b != 0)
        printf("%d\n", a+b);
    }

A+B - 4

    int a,b;
    while(~scanf("%d %d", &a,&b)){
        printf("%d\n", a+b);
    }

더하기 사이클

    int num, firNum, secNum, sumNum, count, result;
    result = 0;
    count = 0;
    
    scanf("%d",&num);
    
    if (num < 10)
            num *= 10;

    result = num;

    while (1) {
         firNum = result / 10;
         secNum = result % 10;
         sumNum = firNum + secNum;
         result = (secNum * 10) + (sumNum % 10);
         count++;

         if (num == result)
             break;
    }
    printf("%d", count);

헷갈릴땐 변수 다시 정리하고 세분화

C++ 출력만 해보고 앞으로 C#으로 해보겠습니다. 유니티로 취업을 할거고 계속 사용해서 친해져야하는 언어이므로 앞으로 문제는 C#으로 풀어보겠습니다.

두 수 비교하기

using System;

class Program {
    static void Main(){
        string str;
        int a,b;
        
        str = Console.ReadLine();
        string[] strArr = str.Split(' ');
        a = Convert.ToInt32(strArr[0]);
        b = Convert.ToInt32(strArr[1]);
        
        if(a < b) 
            Console.WriteLine("<");
        else if(a > b) 
            Console.WriteLine(">");    
        else if(a == b) 
            Console.WriteLine("==");
        else
            Console.WriteLine("잘못된 입력 값입니다.");
    }
}

시험 성적

string str;
int score;

str = Console.ReadLine();
score = Convert.ToInt32(str);

if(score >= 90)
    Console.WriteLine("A");
else if(score >= 80)
	Console.WriteLine("B");
else if(score >= 70)
	Console.WriteLine("C");
else if(score >= 60)
	Console.WriteLine("D");
else
	Console.WriteLine("F");

윤년

string str;
int year;
int a = 4;
int b = 100;
int c = 400;
bool yearBool;

str = Console.ReadLine();
year = Convert.ToInt32(str);

yearBool = year%a == 0 && year%b != 0;

if(yearBool || year%c == 0)
	Console.WriteLine("1");
else
	Console.WriteLine("0");

사분면 고르기

	
    int a,b;

    a = int.Parse(Console.ReadLine());
    b = int.Parse(Console.ReadLine());

    if (a > 0 && b > 0)
        Console.WriteLine("1");
    else if(a < 0 && b > 0)
        Console.WriteLine("2");
    else if(a < 0 && b < 0)
        Console.WriteLine("3");
    else if(a > 0 && b < 0)
        Console.WriteLine("4");
    else
        Console.WriteLine("잘못 입력했습니다.");

Convert.ToInt32 보다 int.Parse 속도, 메모리 면에서 더 유리합니다.

알람 시계

        int h,m;
        int setM;
            
        string[] arrStr = Console.ReadLine().Split(" ");
        setM = 45;
        
        h = int.Parse(arrStr[0]);
        m = int.Parse(arrStr[1]);
        m -= setM;
        if (m < 0) {
            m = Math.Abs(m);
            m = 60 - m;
            h -= 1;
        }
        if(h < 0)
        {
            h = 23;
        } 
        Console.WriteLine("{0} {1}", h,m);

if문 완료했습니다.

보스 부분은 아직 보완해야할 부분이 많아서 건너띄고 리팩토링 후 포스팅할 생각입니다.

그럼 그전에 셰이더 부분부터 보겠습니다.

계산을 하는 부분입니다. 앞전에 셰이더 튜토리얼에서 작성한 부분입니다.

기본 툰 셰이더는 텍스쳐로 값을 받아서 적용시켜야해서 기존 툰 셰이더보다 코드로 툰 셰이더를 작성해서 사용해보자라는 취지로 만들었습니다. 왼쪽이 기존 셰이더인 그림자를 적용 안한 모습입니다.

오른쪽은 어두운면엔 간접광인 엠비언트 라이트를 추가하고 그림자와 빛 사이 스무브 스텝(smoothstep) 함수를 사용하여 매끄럽게 블렌딩해줬습니다.

다음은 정반사(Specular reflection)와 림 라이트 (Rim lighting)을 만들어서 적용 시켰습니다. 정반사는 보는 방향인 즉, 카메라가 보는 방향을 따라 움직이는 뚜렷한 빛반사입니다.

림 라이트는 물체에 가장자리에 조명을 추가해서 툰 셰이더에서 오브젝트를 돋보이게 하기 위해 사용했습니다. 카메라 시점에서 멀리 향하는 표면에 값을 구하는것이며 노말벡터와 뷰 방향의 내적을 취하고 그것을 반전시킨 값입니다.

이렇게 툰 셰이더를 완성시켜 적용시켰습니다.

팀프로젝트를 마무리 단계는 코드를 분석하여서 정리하기로 하였습니다. 전 플레이어 연출인 카메라 부분 및 낙하 판정을 하는 부분을 분석해보려고 합니다.

협업한 친구가 코드를 잘 정리하여 보내주었습니다.

굿

카메라가 벽에 닿을 시 처리하는 부분

    /*초기 값 설정*/
    private float defaultPosition;
    private float targetPosition;
    
    public Transform cameraTransform;
	
    defaultPosition = cameraTransform.localPosition.z;

    cameraTransform.localRotation = Quaternion.identity;
    cameraTransform.parent = pivotTransform;
    
    // TPS 카메라 보정
    // 카메라와 플레이어 사이에 물체가 있을 때 레이로 충돌판정, z 거리조절
    private void CameraCollision()
    {
        // 카메라 기본위치
        // 충돌이 없는경우 이 값으로 이동 될 수 있게 따로 변수 만듦
        targetPosition = defaultPosition;

        RaycastHit hit;
        // 카메라에서 카메라 pivot 으로 향하는 방향벡터
        Vector3 direction = cameraTransform.position - pivotTransform.position;
        // 정규화(방향만 필요함)
        direction.Normalize();

        // 스피어캐스트 사용, pivotTransform.position위치에서 direction 방향으로 광선을 쏘고 그 광선을 따라서
        // 반지름 0.2크기의 구를 날려서 부딪히는지 체크, 마지막 매개변수는 광선의 사거리로 카메라와 플레이어 사이 기본거리
        if (Physics.SphereCast(pivotTransform.position, 0.2f, direction, out hit, Mathf.Abs(targetPosition)))
        {
            // 플레이어와 카메라 사이 물체가 있는경우
            // distance = pivot과 충돌물체 사이의 거리값 저장
            float distance = Vector3.Distance(pivotTransform.position, hit.point);
            
            // 카메라 위치값 보정
            // 카메라z 위치 = distance - 보정값(카메라 얼마나 플레이어 쪽으로 땡길지 값)
            // - 붙은 이유 : 카메라 로컬 좌표, 플레이어 뒤에서 찍기 때문에
            targetPosition = -(distance - tps_CameraCollisonDistance);
        }

        // 위에서 보정 후에
        // 카메라와 pivot 사이거리가 보정값보다 짧은경우, 즉 너무 벽에 붙어있어서 벽과 플레이어 사이거리가 보정값 보다 짧은 경우
        if (Mathf.Abs(targetPosition) < tps_CameraCollisonDistance)
        {
            // 최소 플레이어와 카메라 사이 거리를 지정해줌
            // 최소값 따로 안만들고 보정값이 적당해서 그대로 사용함
            targetPosition = -tps_CameraCollisonDistance;
        }

        // 보정한 값
        // Lerp로 부드럽게 이동시킴
        cameraPosition.z = Mathf.Lerp(cameraTransform.localPosition.z, targetPosition, Time.deltaTime / tps_cameraOffsetSpeed);

        // 카메라 z위치 최종 보정값 실제 반영
        cameraTransform.localPosition = cameraPosition;

        // 카메라가 바라보는 기준을 pivot으로 해놓은 이유 : 플레이어에 변동사항이 생겨도 수정이 용이하게 하기위함
        // 스피어캐스트 사용이유 : 더 정밀하게 보정할 수 있기 때문에, 그냥 레이캐스트 사용시 체크하지 못하는 부분까지 체크해줌
    }

플레이어 낙하 판정 부분

    // 플레이어 낙하 판정
    // 바닥 거리판정이기 때문에 여기서 플레이어 y위치 처리도 함
    private void PlayerFalling()
    {
        RaycastHit hit;
        // 캡슐콜라이더의 높이의 절반 길이
        float length = capsuleCollider.height * 0.5f;
        // 콜라이더 박스의 중심 점
        Vector3 origin = capsuleCollider.bounds.center;

        // 레이캐스트, 플레이어의 콜라이더 중심으로 부터 아래 방향으로 콜라이더 절반 길이 + 최소 낙하판정 거리
        // 사거리 저렇게 두고 충돌하면 바닥에 닿고 있거나 떨어져도 낙하 동작 나올만큼의 높이가 아닌 경우
        if (Physics.Raycast(origin, Vector3.down, out hit, length + minimumDistanceFalling))
        {
            // 확인용
            Debug.DrawRay(origin, Vector3.down * (length + minimumDistanceFalling), Color.red);
            
            // 이 함수 안에 들어왔으면 바닥에 닿고 잇는 상태
            inputCtrl.isGround = true;

            // hit.distance = 부딪힌 지점까지의 거리
            // 이 거리가 콜라이더 절반 길이보다 길면(= 바닥에 서 있는 모든 경우)
            if (hit.distance > length)
            {
                // 플레이어의 위치 저장, 현재 위치에서 y값만 보정해주기 위해서
                Vector3 newPos = transform.position;

                // 현재 위치의 y값을 충돌지점의 y값으로 바꾸어준다. 즉 바닥의 y좌표랑 플레이어 y좌표랑 똑같이해서 바닥아래 발이 안빠지게 함
                newPos.y = hit.point.y;
                // 변경한 위치를 실제 플레이어 위치에 반영
                transform.position = newPos;
            }