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

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

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


# <br>2주차 - 열혈 C++ 프로그래밍 Chapter 3-4

# <br>구조체

* C언어에서의 구조체
  * “값의 집합”
* C++에서의 구조체 선언
* C++에서의 구조체 변수의 선언

```C++
struct Car
{
    char gamerID[ID_LEN];    
    int fuelGauge;      
    int curSpeed;
};
```

```C++
Car basicCar;
Car simpleCar;
```

* 자료형이란:
  * 값의 집합과 연산의 집합
* C언어에서는 값의 집합만 지원하므로, 다음과 같이 연산의 집합은 전역 함수로 선언해야 한다.
* 이는 error-prone한 구조이다.

```C++
void ShowCarState(Car &car)
{
    cout<<＂소유자ID: ＂<<gamerID<<endl;
    cout<<＂연료량: ＂<<fuelGauge<<＂%＂<<endl;
    cout<<＂현재속도: "<<curSpeed<<"km/s"<<endl<<endl;
}
```

C++에서는 연산 역시 구조체에 선언할 수 있음

```C++
struct Car
{
    char gamerID[CAR_CONST::ID_LEN];    
    int fuelGauge;      
    int curSpeed;       
    void ShowCarState();
};
void Car::ShowCarState()
{
    cout<<“ 사용자ID: "<<gamerID<<endl;
    cout<<“ 연료량: "<<fuelGauge<<"%"<<endl;
    cout<<“ 현재속도: "<<curSpeed<<"km/s"<<endl<<endl;
}
```

# <br>클래스

* 클래스의 선언
  * struct 키워드를 class로 쓰면 된다.
* 클래스와 구조체의 차이:
  * 접근 지시자의 차이
  * 구조체는 기본이 public, 클래스는 기본이 private.

```C++
class Car
{
    char gamerID[CAR_CONST::ID_LEN];    
    int fuelGauge;      
    int curSpeed;       
    void ShowCarState();
};
void Car::ShowCarState()
{
    cout<<“ 사용자ID: "<<gamerID<<endl;
    cout<<“ 연료량: "<<fuelGauge<<"%"<<endl;
    cout<<“ 현재속도: "<<curSpeed<<"km/s"<<endl<<endl;
}
```

# <br>접근제어 지시자

```C++
class Car
{
private:
    char gamerID[CAR_CONST::ID_LEN];    
    int fuelGauge;      
    int curSpeed;       
public:
    void InitMembers(char * ID, int fuel);
    void ShowCarState();
    void Accel();
    void Break();
};
void Car::InitMembers(char * ID, int fuel)
{
    strcpy(gamerID, ID);
    fuelGauge=fuel;
    curSpeed=0;
};
...
int main(void)
{
    Car run99;
    run99.InitMembers("run99", 100);
    run99.Accel();
    run99.Accel();
    run99.Accel();
    run99.ShowCarState();
    run99.Break();
    run99.ShowCarState();
    return 0;
}
```

* public
  * 어디서든 접근 허용
* protected
  * 상속 관계에 놓여있을 때, 유도 클래스에서의 접근 허용
* private
  * 클래스 내에서만 접근 허용
* 일반적인 선언:
  * 세부 구현인 변수는 private으로
  * 인터페이스인 함수는 public으로

# <br>주의점

* private은 클래스에 대한 접근제어 지시자이다.
  * per-class basis이지, per-object basis가 아니다.
  * 서로 다른 객체이더라도, 같은 클래스라면 직접 접근할 수 있다!

```C++
class Vector2D
{
private:
    int x;
    int y;
public:
    Vector2D(int x, int y) : x(x), y(y) {}
    int getX();
    int getY();
    Vector2D plus(Vector2D other)
    {
        // return Vector2D(x + other.getX(), y + other.getY())
        return Vector2D(x + other.x, y + other.y);
    }
};
```

# <br>객체, 멤버변수, 멤버함수

* 클래스:
  * 설계도
* 객체:
  * 설계도를 통해서 생성된 실체(instance)
* 멤버변수:
  * 클래스 내의 변수
* 멤버함수:
  * 클래스 내의 함수

# <br>파일분할

* 클래스의 선언과 정의를 분리한다.
  * 이는 Java에서 interface의 쓰임과 유사하다.
  * 즉, 같은 헤더의 내용을 정의하더라도 서로 다른 방식으로 구현된 여러 .cpp 파일들이 충분히 존재할 수 있다.
    * 이들은 Linker를 통해서 선택될 수 있다.

# <br>파일분할 예시

```C++
<Car.h>
#ifndef __CAR_H__
#define __CAR_H__
namespace CAR_CONST
{
    enum
    {
        ID_LEN      =20,
        MAX_SPD     =200,
        FUEL_STEP   =2,
        ACC_STEP    =10,
        BRK_STEP    =10
    };
}
class Car
{
private:
    char gamerID[20];   
    int fuelGauge;      
    int curSpeed;       
public:
    void InitMembers(char * ID, int fuel);
    void ShowCarState();
    void Accel();
    void Break();
};
#endif
```

선언과 관련한 includ는 헤더 파일에, 구현과 관련한 include는 cpp 파일에!

```C++
<Car.cpp>
#include <iostream>
#include <cstring>
#include "Car.h"
using namespace std;
void Car::InitMembers(char * ID, int fuel)
{
    strcpy(gamerID, ID);
    fuelGauge=fuel;
    curSpeed=0;
};
void Car::Accel()
{
    if(fuelGauge<=0)
        return;
    else
        fuelGauge-=CAR_CONST::FUEL_STEP;
    if((curSpeed+CAR_CONST::ACC_STEP)>=CAR_CONST::MAX_SPD)
    {
        curSpeed=CAR_CONST::MAX_SPD;
        return;
    }
    curSpeed+=CAR_CONST::ACC_STEP;
}
...
```

# <br>객체 활용하기

* 생성
  * 일반적인 변수의 선언방식과 동적 할당방식이 있다.
* 함수 호출
  * <객체 이름>.<멤버함수 이름>

```C++
ClassName objName;
ClassName* ptrObj = new ClassName;
FruitSeller seller;
FruitBuyer buyer;
FruitSeller* objPtr1 = new FruitSeller;
FruitBuyer* objPtr = new FruitBuyer;
```

```C++
FruitSeller seller;
seller.InitMembers(1000, 20, 0);
FruitBuyer buyer;
buyer.InitMembers(5000);
buyer.BuyApples(seller, 2000);
```

# <br>정보은닉과 캡슐화

* Information Hiding
  * 필요한 정보만을 드러낸다.
* Encapsulation
  * 관련있는 값의 집합과 연산의 집합을 묶는다.
* 철학
  * 정보 은닉: API와 세부 구현을 분리하며, 클라이언트는 API만 의존한다.
  * 캡슐화: 특정한 행위를 할 때, 사용자는 “편리”해야 한다.
    * 세부적인 내용들을 클라이언트가 일일이 조작하는 것 대신, 거대한 블랙박스에서 클라이언트 입력과 출력만을 제어한다.
    * 이를 테면, Façade Pattern.

# <br>생성자와 소멸자

* 객체 생성 시 단 한 번만 호출되는 함수
* 특징:
  * 클래스의 이름과 함수의 이름이 동일하다.
  * 반환형이 선언되어 있지 않으며, 실제로 반환하지 않는다.
  * 오버로딩이 가능하다.
  * 매개변수에 디폴트 값을 설정할  있다.

```C++
#include <iostream>
using namespace std;
class SimpleClass
{
    int num1;
    int num2;
public:
    SimpleClass()
    {
        num1=0;
        num2=0;
    }
    SimpleClass(int n)
    {
        num1=n;
        num2=0;
    }
    SimpleClass(int n1, int n2)
    {
        num1=n1;
        num2=n2;
    }
    void ShowData() const
    {
        cout<<num1<<' '<<num2<<endl;
    }
};
```

```C++
int main(void)
{
    SimpleClass sc1;
    sc1.ShowData();
    SimpleClass sc2(100);
    sc2.ShowData();
    SimpleClass sc3(100, 200);
    sc3.ShowData();
    return 0;
}
```

# <br>멤버 이니셜라이저

Rectangle 클래스는 Point 두 개를 지닌다.

멤버 초기자를 이용해 이를 손쉽게 초기화할 수 있다.

```C++
#ifndef __RECTANGLE_H_
#define __RECTANGLE_H_
#include "Point.h"
class Rectangle
{
    Point upLeft;
    Point lowRight;
public:
    Rectangle(const int &x1, const int &y1, const int &x2, const int &y2);
    void ShowRecInfo() const;
};
#endif
```

```C++
#include <iostream>
#include "Rectangle.h"
using namespace std;
Rectangle::Rectangle(const int &x1, const int &y1, const int &x2, const int &y2)
            :upLeft(x1, y1), lowRight(x2, y2)
{
    // empty
}
void Rectangle::ShowRecInfo() const
{
}
```

```C++
class AAA
{
public:
    AAA()
    {
        cout<<"empty object"<<endl;
    }
    void ShowYourName()
    {
        cout<<"I'm class AAA"<<endl;
    }
};
class BBB
{   
private:
    AAA &ref;
    const int #
public:
    BBB(AAA &r, const int &n)
        : ref(r), num(n)
    {    }    
    void ShowYourName()
    {
        ref.ShowYourName();
        cout<<"and"<<endl;
        cout<<"I ref num "<<num<<endl;
    }
};
```

* 멤버 이니셜라이저의 이점:
  * 초기화의 대상을 명확히 인식할 수 있다.
  * 성능에 약간의 이점이 있다.
* const와 참조자 역시 선언이 가능해진다!

```C++
int main(void)
{
    AAA obj1;
    BBB obj2(obj1, 20);
    obj2.ShowYourName();
    return 0;
}
```

# <br>디폴트 생성자

* 생성자는 반드시 최소 하나를 갖는다!
  * 만약 생성자를 선언하지 않으면, 디폴트 생성자가 삽입된다.
  * 디폴트 생성자는 인자를 받지 않으며, 내부적으로 아무런 일도 하지 않는 생성자이다.
* 다음 둘은 동일하다:
* 주의점:
  * malloc()을 이용해 생성하면 생성자는 호출되지 않는다.

```C++
class AAA
{
public:
    AAA()
    {    }
    void ShowYourName()
    {
        cout<<"I'm class AAA"<<endl;
    }
};
```

```C++
class AAA
{
public:
    void ShowYourName()
    {
        cout<<"I'm class AAA"<<endl;
    }
};
```

# <br>private 생성자

* 만약 클래스 내부에서 객체를 생성할 것이라면, private으로 선언하여도 된다.
* 참고:
  * Singleton Pattern

```C++
#include <iostream>
using namespace std;
class AAA
{
private:
    int num;
public:
    AAA() : num(0) {}
    AAA& CreateInitObj(int n) const
    {
        AAA * ptr=new AAA(n);
        return *ptr;
    }
    void ShowNum() const { cout<<num<<endl; }
private:
    AAA(int n) : num(n) {}
};
```

```C++
int main(void)
{
    AAA base;
    base.ShowNum();
    AAA &obj1=base.CreateInitObj(3);
    obj1.ShowNum();
    AAA &obj2=base.CreateInitObj(12);
    obj2.ShowNum();
    delete &obj1;
    delete &obj2;
    return 0;
}
```

# <br>소멸자

* 객체 소멸 시 반드시 호출되는 함수
* 특징:
  * 클래스의 이름 앞에 ‘~’가 붙은 형태의 이름을 갖는다.
  * 반환형이 선언되어 있지 않으며, 실제로 반환하지 않는다.
  * 매개변수는 void형으로 선언되어야 하기 때문에 오버로딩도, 디폴트 값 설정도 불가능하다.
* 이 역시 선언하지 않을 시 자동으로 기본 소멸자가 삽입된다.

```C++
class AAA
{
public:
    AAA()
    {    }
    ~AAA()
    {    }
};
```

# <br>소멸자의 활용

* 소멸자를 이용해 객체 소멸 과정에서 처리해야 할 일들을 자동으로 처리할 수 있다.
* 첨언:
  * 따라서, 동적으로 객체를 할당하는 일만을 처리하는 클래스를 선언하고 생성자와 소멸자를 이용해 이를 편리하게 다룰 수 있다. (클래스 바깥의 사용자는 이를 신경 쓰지 않아도 됨)
  * 이러한 것들을 컨테이너 클래스라고 한다.
    * 가령, vector 클래스

```C++
#include <iostream>
#include <cstring>
using namespace std;
class Person
{
private:
    char * name;
    int age;
public:
    Person(char * myname, int myage)
    {
        int len=strlen(myname)+1;
        name=new char[len];
        strcpy(name, myname);
        age=myage;
    }
    void ShowPersonInfo() const
    {
        cout<<"�̸�: "<<name<<endl;
        cout<<"����: "<<age<<endl;
    }
    ~Person()
    {
        delete []name;
        cout<<"called destructor!"<<endl;
    }
};
```

```C++
int main(void)
{
    Person man1("Lee dong woo", 29);
    Person man2("Jang dong gun", 41);
    man1.ShowPersonInfo();
    man2.ShowPersonInfo();
    return 0;
}
```

# <br>객체 배열

```C++
class Person
{
private:
    char * name;
    int age;
public:
    Person(char * myname, int myage)
    {
        int len=strlen(myname)+1;
        name=new char[len];
        strcpy(name, myname);
        age=myage;
    }
    Person()
    {
        name=NULL;
        age=0;
        cout<<"called Person()"<<endl;
    }
    void SetPersonInfo(char * myname, int myage)
    {
        name=myname;
        age=myage;
    }
    void ShowPersonInfo() const
    {
        cout<<"이름: "<<name<<", ";
        cout<<"나이: "<<age<<endl;
    }   
    ~Person()
    {
        delete []name;
        cout<<"called destructor!"<<endl;
    }
};
```

일반적인 변수 선언과 같이 선언할 수 있다.

단, 기본 생성자만을 호출할 수 있다.

```C++
int main(void)
{
    Person parr[3];
    char namestr[100];
    char * strptr;
    int age;
    int len;
    for(int i=0; i<3; i++)
    {
        cout<<"이름: ";
        cin>>namestr;
        cout<<"나이: ";
        cin>>age;
        len=strlen(namestr)+1;
        strptr=new char[len];
        strcpy(strptr, namestr);
        parr[i].SetPersonInfo(strptr, age); 
    }
    parr[0].ShowPersonInfo();
    parr[1].ShowPersonInfo();
    parr[2].ShowPersonInfo();
    return 0;
}
```

# <br>객체 포인터 배열

```C++
class Person
{
private:
    char * name;
    int age;
public:
    Person(char * myname, int myage)
    {
        int len=strlen(myname)+1;
        name=new char[len];
        strcpy(name, myname);
        age=myage;
    }
    Person()
    {
        name=NULL;
        age=0;
        cout<<"called Person()"<<endl;
    }
    void SetPersonInfo(char * myname, int myage)
    {
        name=myname;
        age=myage;
    }
    void ShowPersonInfo() const
    {
        cout<<"이름: "<<name<<", ";
        cout<<"나이: "<<age<<endl;
    }   
    ~Person()
    {
        delete []name;
        cout<<"called destructor!"<<endl;
    }
};
```

배열을 선언하는 대신, 객체 포인터 배열을 선언해 기본생성자 호출 없이 초기화해줄 수 있다.

```C++
int main(void)
{
    Person * parr[3];
    char namestr[100];
    char * strptr;
    int age;
    int len;
    for(int i=0; i<3; i++)
    {
        cout<<"이름: ";
        cin>>namestr;
        cout<<"나이: ";
        cin>>age;
        parr[i]=new Person(namestr, age);
    }
    parr[0]->ShowPersonInfo();
    parr[1]->ShowPersonInfo();
    parr[2]->ShowPersonInfo();
    delete parr[0];
    delete parr[1];
    delete parr[2];
    return 0;
}
```

# <br>this 포인터

* 객체 자신의 주소 값을 의미하는 포인터
* 특히, 멤버변수를 참조할 때 유용하게 사용함.
* 가끔은 다음과 같은 엄격한 규칙을 적용하기도 함:
  * 멤버변수를 참조할 때에는 반드시 this 키워드를 붙여 참조한다.

```C++
#include <iostream>
#include <cstring>
using namespace std;
class SoSimple
{
    int num;
public:
    SoSimple(int n) : num(n)
    {
        cout<<"num="<<num<<", ";
        cout<<"address="<<this<<endl;
    }
    void ShowSimpleData()
    {
        cout<<num<<endl;
    }
    SoSimple * GetThisPointer()
    {
        return this;
    }
};
```

```C++
class SoSimple
{
    int num;
public:
    SoSimple(int n)
    {
        this->num = numn;
    }
};
```

# <br>Self-Reference의 반환

* 객체 자신을 참조할 수 있는 참조자를 반환하는 함수를 구성할 수 있다.
* 참고:
  * Chaining
  * Builder Pattern

```C++
#include <iostream>
using namespace std;
class SelfRef
{
private:
    int num;
public:
    SelfRef(int n) : num(n)
    {
        cout<<"SelfRef(int n)"<<endl;
    }
    SelfRef& Adder(int n)
    {
        num+=n;
        return *this;
    }
    SelfRef& ShowTwoNumber()
    {
        cout<<num<<endl;
        return *this;
    }
};
```

```C++
int main(void)
{
    SelfRef obj(3);
    SelfRef &ref=obj.Adder(2);
    obj.ShowTwoNumber();
    ref.ShowTwoNumber();
    ref.Adder(1).ShowTwoNumber().Adder(2).ShowTwoNumber();
    return 0;
}
```

댓글

댓글 쓰기

이 블로그의 인기 게시물

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

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

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

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

[코딩의탑] 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는 그럴듯한 바다를 시뮬레이션할 수 있는 방법을 논문으로 정리해 제안하였습니다. 제가 다룰 내용을 간단히 요약하면 다음과 같습니다: 파도는 일종의 사인파와 코사인파의 합입니다. 따라서 ...
자세한 내용 보기