{{ label!='' ? 'Label : ' : (q!='' ? '검색 : ' : '전체 게시글') }} {{ label }} {{ q }} {{ ('('+(pubs|date:'yyyy-MM')+')') }}

[C++] 스터디 CPPALOM 4주차: 열혈 C++ 프로그래밍 Part 3

(파워 포인트 파일(.pptx)을 Markdown으로 변환하여 업로드하였음)


# <br>상속

모든 멤버를 물려받는다.

UnivStudent는 WhoAreYou()에서 자신이 상속받은 WhatYorName(), HowOldAreYou()를 사용할 수 있다!

```C++
class Person
{
private:
    int age;        // 나이
    char name[50];  // 이름
public:
    Person(int myage, char * myname) : age(myage)
    {
        strcpy(name, myname);
    }
    void WhatYourName() const 
    {
        cout<<"My name is "<<name<<endl;
    }
    void HowOldAreYou() const 
    {
        cout<<"I'm "<<age<<" years old"<<endl;
    }
};
```

```C++
class UnivStudent : public Person
{
private:
    char major[50];     // 전공과목
public:
    UnivStudent(char * myname, int myage, char * mymajor)
        : Person(myage, myname)
    {
        strcpy(major, mymajor);
    }
    void WhoAreYou() const 
    {
        WhatYourName();
        HowOldAreYou();
        cout<<"My major is "<<major<<endl<<endl;
    }
};
```

# <br>생성자

* 자식 클래스의 생성자는 자신이 상속한 부모 클래스의 멤버를 초기화할 의무를 지닌다.
  * 그래서 자식의 생성자는 부모의 생성자를 호출하는 형태로 부모 클래스의 멤버를 초기화하는 것이 좋다.
* private 멤버의 상속
  * 자식 클래스는 부모 클래스의 private 멤버에 접근할 수 없다.
  * private의 범위는 클래스이기 때문이다.

```C++
UnivStudent(char * myname, int myage, char * mymajor)
    : Person(myage, myname)
{
    strcpy(major, mymajor);
}
```

# <br>유도 클래스의 객체 생성 과정

유도 클래스의 객체생성 과정에서 기초 클래스의 생성자는 100% 호출된다.

생성자 호출을 명시하지 않을 시, 기초 클래스의 void 생성자가 호출된다.

```C++
class SoBase
{
private:
    int baseNum;
public:
    SoBase() : baseNum(20)
    {
        cout<<"SoBase()"<<endl;
    }
    SoBase(int n) : baseNum(n)
    {
        cout<<"SoBase(int n)"<<endl;
    }
    void ShowBaseData()
    {
        cout<<baseNum<<endl;
    }
};
```

```C++
class SoDerived : public SoBase
{
private:
    int derivNum;
public:
    SoDerived() : derivNum(30)
    {
        cout<<"SoDerived()"<<endl;
    }
    SoDerived(int n) : derivNum(n)
    {
        cout<<"SoDerived(int n)"<<endl;
    }
    SoDerived(int n1, int n2) 
        : SoBase(n1), derivNum(n2)
    {
        cout<<"SoDerived(int n1, int n2)"<<endl;
    }
    void ShowDerivData()
    {
        ShowBaseData();
        cout<<derivNum<<endl;
    }   
};
```

```C++
int main(void)
{
    cout<<"case1..... "<<endl;
    SoDerived dr1;
    dr1.ShowDerivData();
    cout<<"-------------------"<<endl;
    cout<<"case2..... "<<endl;
    SoDerived dr2(12);
    dr2.ShowDerivData();
    cout<<"-------------------"<<endl;
    cout<<"case3..... "<<endl;
    SoDerived dr3(23, 24);
    dr3.ShowDerivData();
    return 0;
};
```

```C++
case1.....
SoBase()
SoDerived()
20
30
-----------------
case2.....
SoBase()
SoDerived(int n)
20
12
-----------------
case3.....
SoBase(int n)
SoDerived(int n1, int n2)
23
24
```

# <br>유도 클래스의 객체 소멸 과정

스택에 생성된 객체의 소멸순서는 생성순서와 반대이다.

```C++
class SoBase
{
private:
    int baseNum;
public:
    SoBase(int n) : baseNum(n)
    {
        cout<<"SoBase() : "<<baseNum<<endl;
    }
    ~SoBase()
    {
        cout<<"~SoBase() : "<<baseNum<<endl;
    }
};
```

```C++
class SoDerived : public SoBase
{
private:
    int derivNum;
public:
    SoDerived(int n) : SoBase(n), derivNum(n)
    {
        cout<<"SoDerived() : "<<derivNum<<endl;
    }
    ~SoDerived()
    {
        cout<<"~SoDerived() : "<<derivNum<<endl;
    }   
};
```

```C++
int main(void)
{
    SoDerived drv1(15);
    SoDerived drv2(27);
    return 0;
};
```

```C++
SoBase() : 15
SoDerived() : 15
SoBase() : 27
SoDerived() : 27
~SoDerived() : 27
~SoBase() : 27
~SoDerived() : 15
~SoBase() : 15
```

# <br>동적 할당의 경우

생성자에서 동적 할당한 메모리 공간은 소멸자에서 해제한다.

```C++
class Person
{
private:
    char * name;
public:
    Person(char * myname)
    {
        name=new char[strlen(myname)+1];
        strcpy(name, myname);
    }
    ~Person()
    {
        delete []name;
    }
    void WhatYourName() const
    {
        cout<<"My name is "<<name<<endl;
    }
};
```

```C++
class UnivStudent : public Person
{
private:
    char * major;
public:
    UnivStudent(char * myname, char * mymajor)
        :Person(myname)
    {
        major=new char[strlen(mymajor)+1];
        strcpy(major, mymajor);
    }
    ~UnivStudent()
    {
        delete []major;
    }
    void WhoAreYou() const
    {
        WhatYourName();
        cout<<"My major is "<<major<<endl<<endl;
    }
};
```

```C++
int main(void)
{
    UnivStudent st1("Kim", "Mathmatics");
    st1.WhoAreYou();
    UnivStudent st2("Hong", "Physics");
    st2.WhoAreYou();
    return 0;
};
```

```C++
My name is Kim
My major is Mathematics
My name is Hong
My major is Physics
```

# <br>protected

* private < protected < public
  * public이 허용하는 접근의 범위가 가장 넓고, privat이 허용하는 접근의 범위가 가장 좁다.
* protected로 선언된 멤버변수는 이를 상속하는 유도 클래스에서 접근이 가능하다.

```C++
class Base
{
private:
    int num1;
protected:
    int num2;
public:
    int num3;
    Base() : num1(1), num2(2), num3(3)
    {  }
};
class Derived : protected Base { };
int main(void)
{
    Derived drv;
    cout<<drv.num3<<endl; // compile error
    return 0;
}
```

# <br>세가지 형태의 상속

* protected 상속
  * protected보다 접근의 범위가 넓은 멤버는 protected로 변경시켜서 상속하겠다.
* private 상속
  * private보다 접근의 범위가 넓은 멤버는 private로 변경시켜서 상속하겠다.
* public 상속
  * public보다 접근의 범위가 넓은 멤버는 public으로 변경시켜서 상속하겠다.

```C++
class Base
{
private:
    int num1;
protected:
    int num2;
public:
    int num3;
    Base() : num1(1), num2(2), num3(3)
    {  }
};
class Derived : protected Base { };
int main(void)
{
    Derived drv;
    cout<<drv.num3<<endl; // compile error
    return 0;
}
```

# <br>상속의 조건

* IS-A 관계
  * 무선 전화기는 전화기입니다.
  * 노트북 컴퓨터는 컴퓨터입니다.
* 기초 클래스와 유도 클래스 간에 IS-A 관계가 성립하지 않는다면, 적절하지 않은 상속일 수 있다.
* 더 나아가:
  * LSP, Liskov Substitution Principle을 고려해야 한다.

# <br>복합 관계

* Composition 관계, HAS-A 관계의 경우.
  * 경찰은 총을 가지고 있다.

```C++
class Gun
{
private:
    int bullet;     // 장전된 총알의 수
public:
    Gun(int bnum) : bullet(bnum)
    { }
    void Shut()
    {
        cout<<"BBANG!"<<endl;
        bullet--;
    }
};
```

```C++
class Police
{
private:
    int handcuffs;    // 소유한 수갑의 수
    Gun * pistol;     // 소유하고 있는 권총
public:
    Police(int bnum, int bcuff)
        : handcuffs(bcuff)
    {
        if(bnum>0) pistol=new Gun(bnum);
        else       pistol=NULL;
    }
    void PutHandcuff() 
    {
        cout<<"SNAP!"<<endl;
        handcuffs--;
    }
    void Shut()
    {
        if(pistol==NULL) cout<<"Hut BBANG!"<<endl;
        else             pistol->Shut();
    }
    ~Police()
    {
        if(pistol!=NULL) delete pistol;
    }
};
```

```C++
int main(void)
{
    Police pman1(5, 3);
    pman1.Shut();
    pman1.PutHandcuff();
    Police pman2(0, 3);     // 권총소유하지 않은 경찰
    pman2.Shut();
    pman2.PutHandcuff();
    return 0;
}
```

```C++
BBANG!
SNAO!
Hut BBANG!
SNAP!
```

# <br>다형성

부모 클래스 객체에 대한 포인터는 자식 클래스 객체 역시 가리킬 수 있다.

```C++
class Person
{
public:
    void Sleep()
    { 
        cout<<"Sleep"<<endl; 
    }
};
```

```C++
class Student : public Person
{
public:
    void Study() 
    { 
        cout<<"Study"<<endl; 
    }
};
class PartTimeStudent : public Student
{
public:
    void Work() 
    { 
        cout<<"Work"<<endl; 
    }
};
```

```C++
int main(void)
{
    Person * ptr1=new Student();
    Person * ptr2=new PartTimeStudent();
    Student * ptr3=new PartTimeStudent();
    ptr1->Sleep();
    ptr2->Sleep();
    ptr3->Study();
    delete ptr1; delete ptr2; delete ptr3;
    return 0;
}
```

```C++
Sleep
Sleep
Study
```

# <br>다형성을 이용한 문제 해결

* EmployeeHandler는 Employee들의 정보를 관리하며 그것들을 기반으로 의미 있는 정보를 보여준다.
* 문제:
  * 단 하나의 Employee 클래스에만 의존하고 있었으나,
  * 요구사항의 변경으로 인해 Employee뿐만 아니라 PermanentWorker, SalesWorker, TemporaryWorker들 또한 다루어야 한다.
  * EmployeeHandler의 변경을 피하면서 이를 해결할 수 있을까?

```C++
class EmployeeHandler
{
private:
    Employee* empList[50];
    int empNum;
public:
    EmployeeHandler() : empNum(0) 
    { }
    void AddEmployee(Employee* emp)
    {
        empList[empNum++]=emp;
    }
    void ShowAllSalaryInfo() const
    {
        for(int i=0; i<empNum; i++)
            empList[i]->ShowSalaryInfo(); 
    }
    void ShowTotalSalary() const
    {
        int sum=0; 
        for(int i=0; i<empNum; i++)
            sum+=empList[i]->GetPay();
        cout<<"salary sum: "<<sum<<endl;
    }
    ~EmployeeHandler()
    {
        for(int i=0; i<empNum; i++)
            delete empList[i];
    }
};
```

* 해결책:
  * 기존의 Employee 클래스를 상속하는 PermanentWorker, SalesWorker, TemporaryWorker들을 작성한다.
* 또 다른 문제:
  * Employee는 ShowSalaryInfo() 함수가 존재하지 않는다. 결국 컴파일 에러가 난다.

```C++
class Employee
{
private:
    char name[100];
public:
    Employee(char * name) { strcpy(this->name, name); }
    void ShowYourName() const
    {
        cout<<"name: "<<name<<endl;
    }
};
```

```C++
class PermanentWorker : public Employee
{
private:
    int salary;
public:
    PermanentWorker(char * name, int money)
        : Employee(name), salary(money)
    {  }
    int GetPay() const
    {
        return salary;
    }
    void ShowSalaryInfo() const
    {
        ShowYourName();
        cout<<"salary: "<<GetPay()<<endl<<endl;
    }
};
```

```C++
class EmployeeHandler
{
    void ShowAllSalaryInfo() const
    {
        for(int i=0; i<empNum; i++)
            empList[i]->ShowSalaryInfo(); 
    }
};
```

* 해결책:
  * Employee 클래스에 빈 ShowSalryInfo() 함수를 만들고, 이를 오버라이딩하도록 한다.
* 또 다른 문제:
  * 코드는 여전히 Employee 포인터를 이용해서 함수를 호출하므로, 컴파일러는 Employee::ShowSalryInfo()를 호출한다.

```C++
class Employee
{
private:
    char name[100];
public:
    Employee(char * name) { strcpy(this->name, name); }
    void ShowYourName() const { cout<<"name: "<<name<<endl; } 
    void ShowSalaryInfo() const {  }
};
```

```C++
class PermanentWorker : public Employee
{
private:
    int salary;
public:
    PermanentWorker(char * name, int money)
        : Employee(name), salary(money)
    {  }
    int GetPay() const
    {
        return salary;
    }
    void ShowSalaryInfo() const
    {
        ShowYourName();
        cout<<"salary: "<<GetPay()<<endl<<endl;
    }
};
```

```C++
class EmployeeHandler
{
private:
    Employee* empList[50];
public:
    void ShowAllSalaryInfo() const
    {
        for(int i=0; i<empNum; i++)
            empList[i]->ShowSalaryInfo(); 
    }
};
```

# <br>가상 함수

```C++
class First
{
public:
    void MyFunc()
    { cout<<"FirstFunc"<<endl;}
};
class Second: public First
{
public:
    void MyFunc()
    { cout<<"SecondFunc"<<endl; }
};
class Third: public Second
{
public:
    void MyFunc()
    { cout<<"ThirdFunc"<<endl; }
};
int main(void)
{
    Third * tptr=new Third();
    Second * sptr=tptr;
    First * fptr=sptr;
    fptr->MyFunc();
    sptr->MyFunc();
    tptr->MyFunc();
    delete tptr;
    return 0;
}
```

```C++
class First
{
public:
    virtual void MyFunc()
    { cout<<"FirstFunc"<<endl;}
};
class Second: public First
{
public:
    virtual void MyFunc()
    { cout<<"SecondFunc"<<endl; }
};
class Third: public Second
{
public:
    virtual void MyFunc()
    { cout<<"ThirdFunc"<<endl; }
};
int main(void)
{
    Third * tptr=new Third();
    Second * sptr=tptr;
    First * fptr=sptr;
    fptr->MyFunc();
    sptr->MyFunc();
    tptr->MyFunc();
    delete tptr;
    return 0;
}
```

* virtual 키워드를 사용하지 않은 경우:
  * 포인터의 타입에 따라서 함수가 호출된다.
* virtual 키워드를 사용한 경우:
  * 포인터의 타입에 상관 없이 실제 가리키는 객체에 따라서 함수가 호출된다.

```C++
FirstFunc
SecondFunc
ThirdFunc
```

```C++
ThirdFunc
ThirdFunc
ThirdFunc
```

# <br>순수 가상함수와 추상 클래스

* virtual 함수 뒤에 = 0을 붙이면 순수 가상함수가 된다.
  * 구현이 없다는 의미이므로, 해당 클래스의 객체를 생성할 수 없다.
  * 이를 추상 클래스라고 말한다.

```C++
class Employee
{
private:
    char name[100];
public:
    Employee(char * name)
    {
        strcpy(this->name, name);
    }
    void ShowYourName() const
    {
        cout<<"name: "<<name<<endl;
    }
    virtual int GetPay() const = 0;
    virtual void ShowSalaryInfo() const = 0;
};
```

# <br>가상 소멸자

* 소멸자를 virtual로 선언하면 가상 소멸자가 되며, 이는 자동으로 유도 클래스의 소멸자부터 우선 호출하도록 만든다.
  * 만약 선언하지 않는다면, 아래 코드의 경우에서 Second 클래스의 소멸자는 호출되지 않는다.
  * First 포인터로 선언되어 있으므로, 컴파일러는 First 클래스의 객체라고 인지하기 때문이다.

```C++
class First
{
private:
    char * strOne;
public:
    First(char * str)
    {
        strOne=new char[strlen(str)+1];
    }
    virtual ~First()
    {
        cout<<"~First()"<<endl;
        delete []strOne;
    }
};
class Second: public First
{
private:
    char * strTwo;
public:
    Second(char * str1, char * str2) : First(str1)
    {
        strTwo=new char[strlen(str2)+1];
    }
    virtual ~Second()
    {
        cout<<"~Second()"<<endl;
        delete []strTwo;
    }
};
```

```C++
int main(void)
{
    First * ptr=new Second("simple", "complex");
    delete ptr;
    return 0;
}
```

# <br>참조자의 참조 가능성

참조자 역시 포인터와 같이 동적으로 객체를 참조할 수 있다.

```C++
int main(void)
{
    Third obj;
    obj.FirstFunc();
    obj.SecondFunc();
    obj.ThirdFunc();
    obj.SimpleFunc();
    Second & sref=obj;
    sref.FirstFunc();
    sref.SecondFunc();
    sref.SimpleFunc();
    First & fref=obj;
    fref.FirstFunc();
    fref.SimpleFunc();
    return 0;
}
```

```C++
class First
{
public:
    void FirstFunc()
    { cout<<"FirstFunc()"<<endl; }
    virtual void SimpleFunc()
    { cout<<"First's SimpleFunc()"<<endl; }
};
class Second: public First
{
public:
    void SecondFunc()
    { cout<<"SecondFunc()"<<endl; }
    virtual void SimpleFunc()
    { cout<<"Second's SimpleFunc()"<<endl; }
};
class Third: public Second
{
public:
    void ThirdFunc()
    { cout<<"ThirdFunc()"<<endl;}
    virtual void SimpleFunc()
    {   cout<<"Third's SimpleFunc()"<<endl; }
};
```

```C++
FirstFunc()
SecondFunc()
ThirdFunc()
Third’s SimpleFunc()
FirstFunc()
SecondFunc()
Third’s SimpleFunc()
FirstFunc()
Third’s SimpleFunc()
```

# <br>가상 함수가 참조되는 방식

* 각 클래스는 자신만의 v-table을 지니고 있다.
  * v-table의 각 key(함수 signature)는 호출되어야 할 함수를 가리키고 있다.
  * 참조를 이용해서 특정 함수 signature를 접근할 때, v-table의 값을 이용해 동적 디스패칭 된다.
* 다음 코드의 경우:
  * pA가 가리키는 객체의 v-table ptr를 확인.
  * v-table ptr는 B 클래스의 v-table을 가리킴.
  * v-table의 virtualFunc()를 확인.
  * virtualFunc() 호출.

```C++
A* pA = new B();
pA->virtualFunc();
```

![](img%5Cweek4_subin0.png)

# <br>다중 상속

* 둘 이상의 클래스를 동시에 상속하는 것이다.
* 다중 상속에는 모호성이 있다:
  * 두 기초 클래스에 동일한 이름의 멤버가 존재하는 경우.
  * 해결책: 직접 범위를 명시한다.

```C++
#include <iostream>
using namespace std;
class BaseOne
{
public:
    void SimpleFuncOne() { cout<<"BaseOne"<<endl; }
};
class BaseTwo
{
public:
    void SimpleFuncTwo() { cout<<"BaseTwo"<<endl; }
};
class MultiDrived : public BaseOne, protected BaseTwo
{
public:
    void ComplexFunc()
    {
        SimpleFuncOne();
        SimpleFuncTwo();
    }
};
int main(void)
{
    MultiDrived mdr;
    mdr.ComplexFunc();
    return 0;
}
```

```C++
class MultiDrived : public BaseOne, protected BaseTwo
{
public:
    void ComplexFunc()
    {
        BaseOne::SimpleFunc();
        BaseTwo::SimpleFunc();
    }
};
```

# <br>가상 상속

```C++
class Base
{
public:
    Base() { cout<<"Base Constructor"<<endl; }
    void SimpleFunc() { cout<<"BaseOne"<<endl; }
};
class MiddleDrivedOne : virtual public Base
{
public:
    MiddleDrivedOne() : Base()
    {
        cout<<"MiddleDrivedOne Constructor"<<endl; 
    } 
    void MiddleFuncOne() 
    { 
        SimpleFunc();
        cout<<"MiddleDrivedOne"<<endl; 
    }
};
class MiddleDrivedTwo : virtual public Base
{
public:
    MiddleDrivedTwo() : Base()
    {
        cout<<"MiddleDrivedTwo Constructor"<<endl; 
    } 
    void MiddleFuncTwo() 
    { 
        SimpleFunc();
        cout<<"MiddleDrivedTwo"<<endl; 
    }
};
```

* 이런 구조의 경우, LastDerived는 Base를 두 번 상속 받게 된다.
  * virtual 키워드를 이용해서 단 한 번만 상속받게 할 수 있다.

```C++
class LastDerived : public MiddleDrivedOne, public MiddleDrivedTwo
{
public:
    LastDerived() : MiddleDrivedOne(), MiddleDrivedTwo()
    {
        cout<<"LastDerived Constructor"<<endl; 
    }
    void ComplexFunc()
    {
        MiddleFuncOne();
        MiddleFuncTwo();
        SimpleFunc();
    }
};
int main(void)
{
    cout<<"객체 생성 전 ..... "<<endl;
    LastDerived ldr;
    cout<<"객체 생성 후 ..... "<<endl;
    ldr.ComplexFunc();
    return 0;
}
```

```C++
int main(void)
{
    cout<<"객체 생성 전 ..... "<<endl;
    LastDerived ldr;
    cout<<"객체 생성 후 ..... "<<endl;
    ldr.ComplexFunc();
    return 0;
}
```

```C++
객체 생성 전 .....
Base Constructor
MiddleDerivedOne Constructor
MiddleDerivedTwo Constructor
LastDerived Constructor
객체 생성 후 .....
BaseOne
MiddleDerivedOne
BaseOne
MiddleDerivedTwo
BaseOne
```

댓글

댓글 쓰기

이 블로그의 인기 게시물

[코딩의탑] 4층: 툰 쉐이딩

이미지
가끔은 만화스러운 느낌이 좋을 때도 있죠.   셀 쉐이딩(Cel shading)이라고도 불리는 툰 쉐이딩 기법은 절제된 빛 표현으로 화면을 그리는 비사실적(non-photorealistic) 렌더링 기법 중 하나입니다.  <Borderlands 시리즈>   이러한 툰 쉐이딩은 다양한 방식으로 실현되고 있으며, 언리얼 엔진을 활용한 툰 쉐이딩 역시 어렵지 않습니다. 특히, 포스트 프로세싱을 이용하여 만화스럽게 후처리를 해주는 방법은 클라이언트 프로그래머들이 손쉽게 사용할 수 있는 방법입니다.   하지만, 포스트 프로세싱을 이용한 툰 쉐이딩은 다음과 같은 단점이 존재하는데요: 포스트 프로세싱 자체의 비용이 존재합니다. 특정한 머티리얼에만 툰 쉐이딩을 적용하기 어렵습니다. (커스텀 스텐실 버퍼를 활용하는 것이 대표적인 방법이며, 이는 개발자를 피곤하게 합니다)   따라서, 우리는 포스트 프로세싱을 활용하지 않는 툰 쉐이딩을 구현해보도록 하죠. 우리는 다음을 구현할 것입니다: 특정 물체의 윤곽선을 추가로 렌더링합니다. 특정 물체의 음영을 부드럽지 않은 단계별 음영으로 변경합니다. 이들의 사용 여부와 윤곽선 굵기, 색을 머티리얼 에디터 속성으로 결정할 수 있습니다. 반복되는 컴파일을 줄이기 위해 머티리얼 인스턴스로 만들 수 있으며, 윤곽선의 굵기를 재컴파일 없이 변경할 수 있습니다.   이는  언리얼 엔진 5의 소스를 직접 수정하는 방법임에 주의하세요. 이러한 방법 역시 마법이 아니므로, 비용이 존재합니다. 이는 차차 이야기하도록 하겠습니다. 그 전에 언리얼 엔진 5를 살펴보도록 하죠. 렌더링 패스 디퍼드 쉐이딩으로 렌더링에 필요한 다양한 정보를 담는 버퍼들   언리얼 엔진은 기본적으로 PC 게임에 한해 디퍼드 쉐이딩을 수행합니다. 디퍼드 쉐이딩이란 포워드 쉐이딩의 반대 개념입니다. 한 물체를 렌더링한다고 생각해보죠. 그 물체의 3차원 세계 좌표와 물체 표면의 법선, 표면 거칠기의 정도,...
자세한 내용 보기

[코딩의탑] 5층: 포탈(Portal), 더 나아가기

이미지
2층에서 많은 부족함이 있었죠..   2층 에서 우리가 구현한 포탈은 다음과 같은 부족함이 있습니다: 포탈을 단순히 월드에 배치하기만 했으며, 포탈 건의 요구사항을 고려하지 않았습니다. 가령 포탈은 벽에 생성될 수 있어야 합니다. 플레이어의 포탈 이동만을 고려했습니다. 큐브 등 다른 오브젝트 역시 통과할 수 있어야 합니다. 포탈에 걸쳐있는 오브젝트는 포탈 양면에서 보일 수 있어야 합니다. 즉, 오브젝트의 복사가 이루어져야 합니다. Near plane clippng으로 인해 포탈에 들어가기 직전 카메라가 평면과 겹치는 순간, 포탈 평면의 뒷면 모습이 비춰집니다. 포탈에 비추는 플레이어의 모습이 3인칭으로 보여야 합니다. 효율적인 포탈 재귀 렌더링 방법이 필요합니다. 복습해봅시다. 벡터와 점의 변환   포탈 건너편으로 이동하는 효과를 주기 위해서, 우리는 적절히 오브젝트를 이동 및 회전시켜야 합니다. 속도 역시 적절한 방향으로 보존되어야 하죠. 포탈   먼저 위치와 속도는 3차원 벡터로 표현될 수 있습니다. 그리고 이것이 포탈과 포탈 사이에서 자연스럽게 이어져야 하죠. 마치 포탈이 붙어있는 것처럼요! 다음 그림을 참고해보세요. 블루 포탈과 오렌지 포탈은 서로가 위 방향 축을 기준으로 180도 회전한 상태에서 맞붙어있는 것처럼 느껴야 합니다. 블루 포탈과 오렌지 포탈   이는 각 포탈을 일종의 지역 좌표계로 생각해볼 수 있습니다. 포탈의 [앞 방향 벡터, 우측 방향 벡터, 위 방향 벡터]를 각각 [X, Y, Z]축으로 삼는 셈이죠. 우리는 마치 "이어져 있는" 환상을 선사해야 하므로, 한쪽 지역 좌표계의 좌표 값을 그대로 다른쪽 지역 좌표계의 좌표 값으로 자연스럽게 넘겨주면 됩니다. 다양한 방법이 있겠지만 성능을 위해, 각 축에 대한 내적의 값을 이용하도록 합시다. 각 축은 정규화되어 있고 수직이므로, 내적을 이용할 수 있습니다. 좌표계의 변환 소스 코드: APortal::TransformVectorToDestSpace(), Tra...
자세한 내용 보기

[코딩의탑] 3층: 바다 렌더링

이미지
바다를 그려봅시다.   수많은 게임들은 바다를 배경으로 하고 있습니다. 굳이 바다를 게임의 메인 배경으로 하지 않더라도, 게임 어느 중간에는 꼭 바다를 볼 수 있는 순간이 나오기 마련이죠.  <Sea of Thieves>   이러한 바다를 유체역학적 지식으로 구현하는 것은 쉽지 않습니다. 화면에 보이는 입자가 너무 많아 현실적으로 계산 능력이 부족하기 때문입니다. 따라서 많은 게임들은 바다를 구현하기 위해서 수많은 편법을 활용하고 있습니다. 대표적인 방법은 Displacement Mapping(변위 매핑)을 이용하는 것이죠.  Displacement Mapping   Displacement Mapping이란 Displacement Map을 이용해 물체를 구성하는 일련의 정점들을 재배치하는 것을 의미합니다. 가령, 평평한 격자의 물체가 있고 다음과 같은 두 개의 Displacement Map이 있다면 우리는 파도와 같은 현상을 만들어낼 수 있습니다. 하나는 큰 파도(저주파)를, 다른 하나는 작은 파도(고주파)를 재현합니다. 흰색일수록 위에 있으며, 검은색일수록 아래에 있게 됩니다.   이러한 Displacement Map들을 겹친 후에, 서로 다른 방향으로 움직이게 만들고 겹쳐진 값을 이용해서 Displacement Mapping을 한다면 저렴한 연산으로 파도와 같은 환상을 만들어낼 수 있습니다. 하지만 이 방법은 정적으로 파도가 만들어진다는 한계가 있습니다. 바람의 방향, 파도의 세기 등을 조절하기가 어렵죠. 조금 더 멋진 Displacement Map을 만들 수 있는 방법이 있을까요? Jerry Tessendorf의 'Simulating Ocean Water'   영화 프로듀서이자 교수인 Tessendorf는 그럴듯한 바다를 시뮬레이션할 수 있는 방법을 논문으로 정리해 제안하였습니다. 제가 다룰 내용을 간단히 요약하면 다음과 같습니다: 파도는 일종의 사인파와 코사인파의 합입니다. 따라서 ...
자세한 내용 보기