์์ฑ์: ๊น์ํ(erunc0), ์ต๊ด์(woodpage)
"Advanced 3D Game Programming using DirectX" - study.
"Advanced 3D Game Programming using DirectX" - study.
Contents
GameLibrary( http://www.zeropage.org/~erunc0/study/d3d/GameLib.zip )๋ฅผ ๋ง๋ค์ด ๊ฐ๋ฉด์ ์ฑ ์ ๋ด์ฉ์ ๋ณธ๋ค๋.. ๋ญ๋ญ๋ญ..
๋ง๋ง ๊ทธ๋ ์ง, library๋ถ๋ถ์ ๋์ถฉ ํ๋ ๋๋์ด ๋๋๊ฑด ์์ธ์ง.
๋ญ, library๋ถ๋ถ์ api ์ด๊ธฐํ ๋ฃจํด ๋ถ๋ถ์ ๋์ด๊ณ , DX ๋ ์ญ์ ์ด๊ธฐํ ๋ถ๋ถ์ ๋๋ฅผ
๋ฌถ์ด ๋์ ์ ๋์ด๊ธฐ ๋๋ฌธ์ ์ดํดํ๋๋ฐ ์ด๋ ค์์ ์์๋ค. --;;
Game ์ชฝ ์ฑ ์ ์ฌ์ D3D๋ฅผ ๋ณธํ, 3D๋ฅผ ๊ณต๋ถํ๋ ค๋ ๋ง์์ผ๋ก ์๋ค. ๋ฌด๋ฆฌ์์ด ์์ ๋ฅผ ๋ณด๋์์ผ๋ก ํ ๊ฒ์.
2.1. 1์ 8์ผ ¶
- ์ํ ์.. ๋ง์ ๋ค์ง ์๋๋ค. ๋ฌด์จ ์๋ฆฌ์ธ์ง ๊ฐํผ๋ฅผ ์ก์ง ๋ชปํ๋๊ฒ ํ์ค์ด๋ค. ๊ด๋ จ ์ฑ
์ด๋ผ๋ ์ข ๋ด์ผ ํ๊ฒ ๋ค.
์ฝ๊ฐ์ ์ค๋ช ์ด ๋ฏธํกํ๊ฒ ๊ฐ๋ค. ๋ด๊ฐ ๋ชจ์๋ฅด๊ธฐ ๋๋ฌธ์ผ์๋ ์์ง๋ง, ใ ใ ใ
์์ง๊น์ง, ์์ ๋ค์ด ์์ ๋ฅผ ๋ชป๋ณด๋ค. 3D object๋ฅผ ๋ณธ์ ์ด ์์. ์์ง๊น์ง.. --; - 232p/602p...
- ๊ด์ ์ด์ฑ
๋ฎ์์ง ํ 20๋๊ฑฐ ๊ฐ๋ค. ๋์ธต๋์ธต ๋ด๊ฐ์ง๊ณ ๊ธฐ์ต์ด ์๋๋ค. ๋๊ฐ์ ์ด๋
ผ๊ฑฐ๋ฅผ ๋ณด๋๊ฑฐ๋ก ์์ํ๋ค.
2.2. 1์ 9์ผ ¶
- potential function์ ๋ํด์๋ง ๋ดค๋ค.. ์ฝ๊ฐ ์ธ๋งํ ์๊ณ ๋ฆฌ์ฆ(?) ์ธ๊ฒ ๊ฐ๋ค. ใ
ใ
ใ
๋ค์์ ๋์ค๋ PathPlan์ ๊ดํ์๊ธฐ๋ ์ฌ์ด๊ฒ ๊ฐ์๋ฐ. ์ฅ๋์ด ์๋๋ค.
๋จธ๋ฆฌ ์ํ๋ค. - 249p/602p...
- ์ ์๋ ๋๋๊ฑฐ์ง๋ง ์ด์ฑ
์ D3D์ด๋ณด์์๊ฒ๋ ์ข ์๋๊ฑฐ ๊ฐ๋ค. ์ค๋ ๋์๊ด์๊ฐ์ ์ฑ
์ข ๋น๋ ค์ผ๊ฒ ๋ค ๊ด์
- ์ฑ
๋น๋ฅด๋ฌ ๊ฐ๋ค. 3D์ ๊ดํ์ฑ
.. --+ ๋ฌด์ ์ฑ
์ด ๊ฒ ์ด๋ณด์๋ฅผ ์ํ๊ฒ ์๋๊ฑฐ ๊ฐ์ด.. --+ ์งฑ๋ ์งฑ๋.. ์ํ
2.4. 1์ 11์ผ ¶
- ์ ์ ์ธ๋. ๊ด์์ดํํ
๋น๋ฆฐ ์ฑ
์ผ๋ก 3D๋ฅผ ๊ณต๋ถ.
~cpp ์ฟ ์ฟ .. ์ด์ฌ์ด๊ตฌ๋.. ^^a.. DX ๊ณต๋ถํ๋ฉด ๋์ค ๊ฐ์ผ๋ค์ค.. ํคํค.. ๋๋ ์ง๊ธ ํ๊ตฌ ์๋๊ฑฐ.. ์๊ฐ๋๋ฉด ์ฌ๊ธฐ๋ค(์ํค..) ์ธ๊ป.. ๋๋ค๋ ๊ณง ํ์ํด์ง ๋ด์ฉ์ด ์์ํ ๋.. ๊ทผ๋ฐ ์ง๊ธ์ ๋ด์ฝ๊ฐ ์ข ์์๋ผ์.. ์๊ฐ์ ์ซ๊ธฐ๋ ๊ด๊ณ๋ก.. ์ธ์ ๊ฐ.. ๊ผญ.. ^^;; - ํด์ฑ
์ค์ท.. ํด์ฑ์ด๊ฐ ๊ธ์ ์ผ๋ค! --์์ฒ
3.1. Chapter 1. ¶
์ด๋ฐ ์ข
๋ฅ์ ์ฑ
๋ค์ด ๋ค ๊ทธ๋ ๋ฏ์ด, winapi๋ฅผ ์ฌ์ฉํ๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์, ์ด๋ฐ์ ํ chapter๋ ๊ฑฐ์๋ค winapi๋ฅผ ์ฌ์ฉํด์
"Hello, World!"๋ฅผ ์ฐ๋ source๋ฅผ ๋ฃ์ด ์ค๋ค. --;
๊ทธ๋ ๊ธฐ ๋๋ฌธ์, ์ด๋ฐ์ ํ chapter๋ ๊ฑฐ์๋ค winapi๋ฅผ ์ฌ์ฉํด์
"Hello, World!"๋ฅผ ์ฐ๋ source๋ฅผ ๋ฃ์ด ์ค๋ค. --;
3.2. Chapter 2. ¶
DX ์ด๊ธฐํ ๋ฃจํด๊ณผ, game loop(message loop)๋ฅผ ํฌํจํ library๋ฅผ ์ค์ ๋ก ๋ง๋ ๋ค.
๊ทธ๋ฆฌ๊ณ , ์์ source 1๊ฐ์ ๋.. ์ฌ๊ธฐ ๊น์ง ๋ดค์.. - ๊ณง update , 01.06.2002 Sun
...
์ฌ์ฌ ์ฑ ์ด ์ง์ฆ๋๋ ค๊ณ ํ๋ค. --+ ๊ทธ๋ฅ ๊ฐ๋จํ๊ฒ ์ฑ ์์ ์ ๊ณตํ๋ library๋ฅผ ์ฐ๋ฉด chapter2๋ ์์งํ
๋ณด์ง ์์๋ ๋ ๊ฒ ๊ฐ๋ค. ๋ฌด์จ ์๋ฆฌ๋ค์ ํ๋์ง. ์ ๋ถ ์ด๊ธฐํ.. --+ ํจ์ ์ค๋ช ๋ฟ์ด๋ค. ํ๋ฏธ.. ๊ทธ๋ฅ..
์ผ๋ฐ์ ์ธ 3D์ด์ผ๊ธฐ๋ฅผ ์ด๊ฒ์.. Game์ชฝ์ ์ฌ์.. T-T ์๋ฌดํผ ๋ณด๊ธฐ๋ ๋ค ๋ด์ผ์ง. DX ๋ ํ ๊ฒ์ด ์ ๋ง ์ด๊ธฐํ ๋ฟ์ด๋๊ฐ?
chapter 3 ๋ถํฐ๋ ์ํ์ด๋๋๋ค.. --;;
์ด๊ฑฐ ์ ๋ฆฌํ๋๊ฑด ๋ฌด๋ฆฌ๋ค--;
๊ทธ๋ฆฌ๊ณ , ์์ source 1๊ฐ์ ๋.. ์ฌ๊ธฐ ๊น์ง ๋ดค์.. - ๊ณง update , 01.06.2002 Sun
...
์ฌ์ฌ ์ฑ ์ด ์ง์ฆ๋๋ ค๊ณ ํ๋ค. --+ ๊ทธ๋ฅ ๊ฐ๋จํ๊ฒ ์ฑ ์์ ์ ๊ณตํ๋ library๋ฅผ ์ฐ๋ฉด chapter2๋ ์์งํ
๋ณด์ง ์์๋ ๋ ๊ฒ ๊ฐ๋ค. ๋ฌด์จ ์๋ฆฌ๋ค์ ํ๋์ง. ์ ๋ถ ์ด๊ธฐํ.. --+ ํจ์ ์ค๋ช ๋ฟ์ด๋ค. ํ๋ฏธ.. ๊ทธ๋ฅ..
์ผ๋ฐ์ ์ธ 3D์ด์ผ๊ธฐ๋ฅผ ์ด๊ฒ์.. Game์ชฝ์ ์ฌ์.. T-T ์๋ฌดํผ ๋ณด๊ธฐ๋ ๋ค ๋ด์ผ์ง. DX ๋ ํ ๊ฒ์ด ์ ๋ง ์ด๊ธฐํ ๋ฟ์ด๋๊ฐ?
chapter 3 ๋ถํฐ๋ ์ํ์ด๋๋๋ค.. --;;
- Chapter 2: skip. ์ด๊ธฐํ ๋ถ๋ถ์ ๋. ํก์ฑ ์์ค์. ๋ฌด์จ ์๋ฆฌํ๋์ง ๋ชป์์ ๋จน์ ์ ๋์.
์ด๊ฑฐ ์ ๋ฆฌํ๋๊ฑด ๋ฌด๋ฆฌ๋ค--;
~cpp ์ถ์ฒ ๋์: Inside DirectX (ํ์๋ก ํ๋ค๋ฉด ๋งํ์์ค. ์ ์์ฑ ์ผ๋ก ์์ด์. --;;) Tricks of the Windows Game Programming Gurus : Fundamentals of 2D and 3D Game Programming. (DirectX, DirectMusic, 3D sound)
3.3. Chapter 3. 3D ์ํ์ ๊ธฐ์ด (50%~60%) ¶
์ด chapter๋ math3D๋ผ๋ library๋ฅผ ๋ง๋๋ chapter์ด๋ค
.. 1์ 8์ผ ํ์ฌ.. ์ด ๋ถ๋ถ์ ์์ฒญ๋ ๋ณํ๊ฐ ์๊ตฌ.. --a
์ฑ ์ ๋ด์ฉ์ค ๋ชจ๋ฅด๋ ๊ฒ์ด ๋๋ฌด ๋ง๋ค. ์๋, ๋ง์ด ์ด๋ ค์ด๊ฒ ๊ฐ๋ค.
.. 1์ 8์ผ ํ์ฌ.. ์ด ๋ถ๋ถ์ ์์ฒญ๋ ๋ณํ๊ฐ ์๊ตฌ.. --a
์ฑ ์ ๋ด์ฉ์ค ๋ชจ๋ฅด๋ ๊ฒ์ด ๋๋ฌด ๋ง๋ค. ์๋, ๋ง์ด ์ด๋ ค์ด๊ฒ ๊ฐ๋ค.
3.3.1. ์ ¶
์ ์ 3D ๊ทธ๋ํฝ์์ ๊ฐ์ฅ ์ค์ํ ์์๋๋๋ค. ์ฑ
์์ ๊ทธ๋ฌ๋ฐ์.
- ์ ์ 3D ๊ณต๊ฐ์์์ ํ๋์ ์์น์ด๊ณ , ๋ฒกํฐ๋ 3D๊ณต๊ฐ ๋ด์์ ์์ ์ผ๋ก๋ถํฐ ํ๋์ ์์น๋ฅผ ์๋ ์ง์ ์ด๋ค. -
vector(3D ๊ณต๊ฐ์์ ์ ์ด ์๋ ์ผ์ ํ ๊ฑฐ๋ฆฌ)์ ํฌ๊ธฐ (magnitude)๋ฅผ ๊ตฌํ๋ ๊ณต์์
i<1,0,0>, j<0,1,0>, k<0,0,1>
i, j, k๋ฒกํฐ์ ์ ํ ์กฐํฉ์ผ๋ก 3D๋ด์ ์ด๋ ํ ์ ์ด๋ผ๋ ๋ํ๋ผ์ ์๋ค.
a = <3, 5, 2>
a = 3i+5j+2k
๊ทธ๋ฆฌ๊ณ , ์ด ํน์ฑ์ผ๋ก ์ธํด ํ๋ ฌ๊ณผ ํ๋ ฌ์ ํํํ๋ ๊ณต๊ฐ์ ์ค๋ช ํ ๋ ๋งค์ฐ ์ค์์ ๋๋ค.
- ์ ์ 3D ๊ณต๊ฐ์์์ ํ๋์ ์์น์ด๊ณ , ๋ฒกํฐ๋ 3D๊ณต๊ฐ ๋ด์์ ์์ ์ผ๋ก๋ถํฐ ํ๋์ ์์น๋ฅผ ์๋ ์ง์ ์ด๋ค. -
vector(3D ๊ณต๊ฐ์์ ์ ์ด ์๋ ์ผ์ ํ ๊ฑฐ๋ฆฌ)์ ํฌ๊ธฐ (magnitude)๋ฅผ ๊ตฌํ๋ ๊ณต์์
~cpp ๋ค๋ค ์๊ณ ๊ณ์์ ธ? --;; ํํ..๋จ์ ๋ฒกํฐ- ์ธ๊ฐ์ ์ฃผ์ ์ถ๋ค์ ๋ฐฉํฅ์ ๋ํ๋ด๊ธฐ ์ํ ๋ฒกํฐ.
i<1,0,0>, j<0,1,0>, k<0,0,1>
i, j, k๋ฒกํฐ์ ์ ํ ์กฐํฉ์ผ๋ก 3D๋ด์ ์ด๋ ํ ์ ์ด๋ผ๋ ๋ํ๋ผ์ ์๋ค.
a = <3, 5, 2>
a = 3i+5j+2k
๊ทธ๋ฆฌ๊ณ , ์ด ํน์ฑ์ผ๋ก ์ธํด ํ๋ ฌ๊ณผ ํ๋ ฌ์ ํํํ๋ ๊ณต๊ฐ์ ์ค๋ช ํ ๋ ๋งค์ฐ ์ค์์ ๋๋ค.
3.3.2. point3 ๊ตฌ์กฐ์ฒด ¶
3D์ ์ ์บก์ํ ํ๊ธฐ์ํ ๊ตฌ์กฐ์ฒด.
~cpp struct point3 { union // use union - ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ๋ ์ฑ๋ถ๋ค์ ์ด๋ฆ์ ์ง์ ํ๋๋ฐ ์ฌ์ฉ. { // y๋ณ์์ v[1]๋ณ์๋ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์กฐ๊ฐ์ ๋ํ๋ธ๋ค. struct { float x, y, z; // ๊ตฌ์กฐ์ฒด์ ์ด๋ฆ์ด ์ ์๋์ง ์์์ง ๋๋ฌธ์ x,y,z ์ฑ๋ถ์ ์์ ๋จ์๋ก ์ฌ์ฉ. }; float v[3]; } point3 () {} point3 (float X, float Y, float Z) : x(X), y(Y), z(Z) {} // ์ด๊ธฐํ ๋ชฉ๋ก์ ์ฌ์ฉ. (compiler๊ฐ ์์ ์ ๋ ์ ์ํํ ์ ์๋๋ก ํด์ค๋ค๋๊ตฐ.) // ... };
3.3.3. point3์ ์ฐ์ฐ์์ ๊ธฐ๋ณธ์ ํจ์ ¶
~cpp struct point3 { ... point3 operator +(point3 const &a, point3 const &b); point3 operator -(point3 const &a, point3 const &b); point3 operator *(point3 const &a, float const &b); point3 operator *(float const &a, point3 const &b); point3 operator /(point3 const &a, float const &b); ... }; // ์ขํ ํ ๋น inline void point3::Assign (float X, float Y, float Z) { x = X; y = Y; z = Z; } // vector ๊ฐ inline float point3::Mag () const { return (flaot)sqrt (x*x + y*y + z*z); } // ๊ฑฐ๋ฆฌ์ ์ ๊ณฑ ๊ฐ inline float point3::MagSquared () const { return (x*x + y*y + z*z); } // Normalize inline void point3::Normailze () { float foo = 1/Mag (); x *= foo; y *= foo; z *= foo; }
3.3.4. ๋ฒกํฐ ๋๋ฑ ¶
float์ด๋ double์ด ๋ํ๋ผ์ ์๋ ๋ถ๋์์์ ์ ํ๊ณ๋ก ์ธํด vector๋ผ๋ฆฌ ๋๋ฑํ์ง ์๋์ง๋ฅผ ์ ์ฒ๋ฆฌํ์ง ๋ชปํ๋ค.
๊ทธ๋์, epsilon (์ด ์ฑ ์์๋ 0.001๋ก ์ ์)์ด๋ผ๋ ๊ฒ์ ๋์ด ๊ทธ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค๊ณ ํ๋ค.
๊ทธ๋์, epsilon (์ด ์ฑ ์์๋ 0.001๋ก ์ ์)์ด๋ผ๋ ๊ฒ์ ๋์ด ๊ทธ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค๊ณ ํ๋ค.
~cpp // point3์ ๋ฑ๊ฐ ์ฐ์ฐ์ #define EPSILON 0.001 inline bool operator ==(point3 const &a, point3 const &b) { if (fabs (a.x - b.x) < EPSILON) { if (fabs (a.y - b.y) < EPSILON) { if (fabs (a.z - b.z) < EPSILON) { return true; } } } return false; }
3.3.5. ๋ด์ & ์ธ์ ¶
~cpp // ๋ด์ inline float operator *(point3 const &a, point3 const &b) { return a.x*b.x + a.y*b.y + a.z*b.z; } // ์ธ์ inline point3 operator ^(point3 const &a, point3 const &b) { return point3 ( (a.y*b.z - a.z*b.y), (a.z*b.x - a.x*b.z), (a.x*b.y - a.y*b.x) ); }
--; ๊ณ ๋ฉํ๊ต๋ ๋ฐฐ์ ๋ ๋ด์ ๊ณผ ์ธ์ . ์ง๊ธ๋ณด๋ ๋ฌด์จ ์๋ฆฌ์ธ์ง.. ใ
ใ
ใ
๊ทธ๋ฅ ์ ์ด ๋ดค์. --;
3.3.6. ํด๋ฆฌ๊ณค ¶
ํด๋ฆฌ๊ณค์ ๊ฐ์ฒด์ ํ
๋๋ฆฌ๋ฅผ ํํํ๋๋ฐ ์ฌ์ฉ๋๋ค.
- http://www.gameschool.co.kr/cyberhtm/3dPolygon.htm - ํด๋ฆฌ๊ณค์ ๊ดํ page
- http://www.gameschool.co.kr/cyberhtm/3dPolygon.htm - ํด๋ฆฌ๊ณค์ ๊ดํ page
~cpp template <class type> struct polygon { int nElem; // number of elements in the polygon int maxElem; type *pList; polygon() { nElem = 0; maxElem = 0; pList = NULL; } polygon( int maxSize ) { maxElem = maxSize; pList = new type[maxSize]; } polygon( const polygon &in ) { CloneData( in ); } ~polygon() { DestroyData(); } void CloneData( const polygon &in ) { if( !in.pList ) return; pList = new type[in.maxElem]; maxElem = in.maxElem; nElem = in.nElem; for( int i=0; i<in.nElem; i++ ) { pList[i] = in.pList[i]; } } void DestroyData( ) { delete[] pList; pList = NULL; } polygon& operator=( const polygon<type> &in ) { if( &in != this ) { DestroyData(); CloneData( in ); } return *this; } };
3.3.7. ๋ฉด ¶
3D์์ ๋ฉด์ 2D์ ์ ๊ณผ๊ฐ๋ค.
๋ฉด์ ์ ์ํ๋ ์
์์ ์์ ๋ง์กฑํ๋ ๋ชจ๋ ์ ์ ์ผ์์ <x, y, z>๋ ๋ฐ๋ก ๋ฉด์ ์กด์ฌํ๋ ๋ชจ๋ ์ ๋ค์ด๋ค
๋ฉด์ ์ ์ํ๋ ๊ตฌ์กฐ์ฒด
๋ฉด์ ์ ์ํ๋ ์
~cpp ax + by + cz + d = 0์ผ์์ <a, b, c>๋ ๋ฉด์ ๋ฒ์ (๋ฒ์ : ๊ทธ ๋ฉด๋ด์ ๋ชจ๋ ์ ๋ค์ ๋ํด ์์ง์ธ ๋ฒกํฐ), d๋ ๋ฉด์์ ์์ ๊น์ง์ ๊ฑฐ๋ฆฌ
์์ ์์ ๋ง์กฑํ๋ ๋ชจ๋ ์ ์ ์ผ์์ <x, y, z>๋ ๋ฐ๋ก ๋ฉด์ ์กด์ฌํ๋ ๋ชจ๋ ์ ๋ค์ด๋ค
๋ฉด์ ์ ์ํ๋ ๊ตฌ์กฐ์ฒด
~cpp struct plane3 { point3 n; // Normal of the plane float d; // Distance along the normal to the origin plane3( float nX, float nY, float nZ, float D) : n( nX, nY, nZ ), d( D ) { // All done. } plane3( const point3& N, float D) : n( N ), d( D ) { // All done. } // Construct a plane from three 3-D points plane3( const point3& a, const point3& b, const point3& c); // Construct a plane from a normal direction and a point on the plane plane3( const point3& norm, const point3& loc); // Construct a plane from a polygon plane3( const polygon<point3>& poly ); plane3() { // Do nothing } // Flip the orientation of the plane void Flip(); };
3.3.8. ๋ณํ ¶
3D์ ์์น์ด๋์ด๋ ํ์ ๋ฑ์ด ํ๋ ฌ๋ก ์ด๋ฃจ์ด ์ง๋ค๋ ์๊ธฐ.
์์น ์ด๋์ด์ผ ๋ํด์ฃผ๊ณ ๋นผ์ฃผ๋ฉด ๋๋๊ฑด ๋ค ์๋ ์ฌ์ค์ด๋.. ์ฉ.. --; ํ์ ์ด๋ ์๋ฉด ๋ ๊ฒ ๊ฐ์.
...
ํ์ ์ ๋๋ ์ธ๊ฐ์ง ํ์ค ํ๋ ฌ. (Euler ํ์ )
๋ชจ๋ธ์ ๊ฐ ์ ์ ์ด๋ค ๋ณํ์ ์ ์ฉํ๋ ๊ฒ์ด๋ค.
๊ทธ๋์ ๋ง์ธ๋ฐ, ํ๋ ฌ์ ์์ด์ ์ข์ ์ ์ ๊ณฑํ๊ธฐ ์ ์ ๊ทธ ์ ๋ค์ ๊ฒฐํฉํ ์ ์๋ค๋ ์ ์ด๋ค.
๋ ๊ฐ์ง ํ์ , ์ฆ, A์ B๋ฅผ ์ํํด์ผ ํ ๊ฒฝ์ฐ ๊ฒฐํฉ ๋ฒ์น์ ๋ฐ๋ผ ๋ค์๊ณผ๊ฐ์ด ํ ์ ์๋ค.
์์น ์ด๋์ด์ผ ๋ํด์ฃผ๊ณ ๋นผ์ฃผ๋ฉด ๋๋๊ฑด ๋ค ์๋ ์ฌ์ค์ด๋.. ์ฉ.. --; ํ์ ์ด๋ ์๋ฉด ๋ ๊ฒ ๊ฐ์.
...
ํ์ ์ ๋๋ ์ธ๊ฐ์ง ํ์ค ํ๋ ฌ. (Euler ํ์ )
~cpp Rx (r) = | 1 0 0 | | 0 cos(r) sin(r) | | 0 -sin(r) cos(r) | Ry (r) = | cos(r) 0 -sin(r)| | 0 1 0 | | 0 sin(r) cos(r) | Rz (r) = | cos(r) sin(r) 0 | | -sin(r) cos(r) 0 | | 0 0 1 | ex ) v0 = <2, 0, 0>์ z์ ๊ดํด ์๊ณ ๋ฐฉํฅ์ผ๋ก 45๋ ํ์ v1 = Rz(45)v0 v1์ด v0๋ฅผ z์ ๊ดํด ์๊ณ ๋ฐฉํฅ์ผ๋ก 45๋ ํ์ ์ํจ ์ง์ ์ด๋ค. // ๋ฌธ์ ์ // x, y, z์ถ์ผ๋ก ํ์ ์ํจ ํ๋ ฌ๋ค์ ํ๋๋ก ๊ฒฐํฉํ๊ธฐ์ํ ํ์ค ๋ฐฉ๋ฒ์ด ์๋ค. // ??์ผ์ ํ ํ์ ์ ์ฃผ๊ธฐ์ํด ํด์ผํ ์ผ์ ๋จ์ง ํ์ํ ์ด๋ จ์ ๋ณํ์ ์์๋ด๊ณ
๋ชจ๋ธ์ ๊ฐ ์ ์ ์ด๋ค ๋ณํ์ ์ ์ฉํ๋ ๊ฒ์ด๋ค.
~cpp - ํน์ ํ ์ p์ ์กด์ฌํ๋ ๊ฐ์ฒด๋ฅผ z์ถ์ ๋ฐ๋ผ ํ์ ์ํค๋ ค๋ ๊ฒฝ์ฐ - v = vT(-p) // ์์ ์ผ๋ก ์์น์ด๋ v = vRz(ํ์ด/2) // ํ์ด.. ๋ญ์ง๋ ์๊ฒ ์ง.. ใ กใ ก; v = vT(p) // ๋ค์ ์ p๋ก ์ด๋.but, ๊ฐ์ ๋ค ๋ง๋ค ์ด๋ฐ ์ฐ์ฐ์ ์ํํ๋ ค๋ฉด ๋๋ฌด ๋๋ฆฌ๋ค.
๊ทธ๋์ ๋ง์ธ๋ฐ, ํ๋ ฌ์ ์์ด์ ์ข์ ์ ์ ๊ณฑํ๊ธฐ ์ ์ ๊ทธ ์ ๋ค์ ๊ฒฐํฉํ ์ ์๋ค๋ ์ ์ด๋ค.
๋ ๊ฐ์ง ํ์ , ์ฆ, A์ B๋ฅผ ์ํํด์ผ ํ ๊ฒฝ์ฐ ๊ฒฐํฉ ๋ฒ์น์ ๋ฐ๋ผ ๋ค์๊ณผ๊ฐ์ด ํ ์ ์๋ค.
~cpp v` = (vA)B => v` = v(AB) // ์ค!~
3.3.9. ์ถ-๊ฐ๋ ํ์ ¶
๋ฌด์จ ์๋ฆฌ์ธ์ง...
์์์๋ณธ Eulerํ์ ์ ๋ฌธ์ ์ ์ ๋ณด์ํ ํ์ ํ๋ ฌ.
์์์๋ณธ Eulerํ์ ์ ๋ฌธ์ ์ ์ ๋ณด์ํ ํ์ ํ๋ ฌ.
~cpp | xx(1-cos(r)) + cos (r) yx(1-cos(r)) + z sin(r) xz(1-cos(r)) - y sin(r) 0 | | xy(1-cos(r)) + z sin(r) yy(1-cos(r)) + cos(r) yz(1-cos(r)) - x sin(r) 0 | | xz(1-cos(r)) + y sin(r) yz(1-cos(r)) + x sin(r) zz(1-cos(r)) - cos(r) 0 | | 0 0 0 1 |
3.4.1. ์ถ๋ฐ์ ¶
''
- ์ด๋ป๊ฒ ๊ฐ์ฒด๋ฅผ ์์ง์ด๊ณ , ์ด๋ป๊ฒ ๋๊ณ , ์ด๋ป๊ฒ ๊ฑท๋๋๋ ์์ง์์ ๊ดํ๋ฌธ์ (locomotion or motor skills)
- ๊ฐ์ฒด๊ฐ ์ด๋ป๊ฒ ์ฅ์ ๋ฌผ ๋ฐ ๋ค๋ฅธ ๊ฐ์ฒด๋ค์ ํผํ๋ฉด์ A์์ B๋ก ์ด๋ํ ๊ฒ์ธ๊ฐ? (task generation)
- ์ค์ ์ฌ๊ณ , ๊ฐ์ฒด๋ค์ด ๋ฌด์์ ํ ๊ฒ์ธ์ง ์ค์ค๋ก ๊ฒฐ์ ํ๊ณ ์์ง์ด๋ ๋ฅ๋ ฅ์ ์ด์ฉํ๋ฉฐ ํ๊ณ ์ ํ๋ ๋ฐ๋ฅผ ํํ ๊ณํ์ ์ธ์ฐ๋๊ฒ (acion steering)
3.4.2. ์กฐ์ข - about move 1 ¶
1.์ถ์
๊ฐ๋จํ ์ ์ ๋ฐ๋ผ๊ฐ๋ ๊ฒ. ๋ญ ์๊ณ ๋ฆฌ์ฆ ๊ฐ์๊ฑด ์์ง๋ ์์๊ฒ ๊ฐ๋ค.
2.ํ์ถ
... ํ ๋ง ์์.
3.ํจํด (๊ธฐ๋ณธ)
... ํ ๋ง ์์.
๊ฐ๋จํ ์ ์ ๋ฐ๋ผ๊ฐ๋ ๊ฒ. ๋ญ ์๊ณ ๋ฆฌ์ฆ ๊ฐ์๊ฑด ์์ง๋ ์์๊ฒ ๊ฐ๋ค.
2.ํ์ถ
... ํ ๋ง ์์.
3.ํจํด (๊ธฐ๋ณธ)
... ํ ๋ง ์์.
3.4.3. ์กฐ์ข - 2 ¶
์ ์ ํจ์
์ฐ๋ฆฌ๋ ๋ช ๋ฒฝํ๊ฒ ์ฅ์ ๋ฌผ 2๋ณด๋ค๋ ์ฅ์ ๋ฌผ 1์ ํผํ๊ธฐ๋ฅผ ๋ ์ํ ๊ฒ์ด๋ค.
์ฆ, ์ฅ์ ๋ฌผ 2๋ ํจ์ฌ ๋ ๋ฉ๋ฆฌ ๋จ์ด์ ธ ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ชฉํ ์ง์ ์ ํฅํ ํ๊ท ํ๋ ๋ฒกํฐ์ด๋ค(or ๋ชฉํ ์ง์ ์ ์์น์์ ํ์ฌ ์์น๋ฅผ ๋บ ๊ฒ)
๊ทธ๋ฆฌ๊ณ , ๊ฐ๊ฐ์ ์ฅ์ ๋ฌผ์ ๋ํด ๊ณง์ฅ ๋๋ง๊ฐ ์ ์๋๋ก ํ๋ ํ๊ท ๋ฒกํฐ๋ฅผ ์ฐพ์๋ธ๋ค.
์ด ํ๊ท ๋ฒกํฐ๋ฅผ ํ๋์ ์์๋ก ๊ณฑํ ๋ค์ ๋ค์ ์ฅ์ ๋ฌผ๋ก๋ถํฐ์ ๊ฑฐ๋ฆฌ์
์ ๊ณฑ์ผ๋ก ๋๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋์๋ ๋ฌผ์ฒด๊ฐ ๋ฐฉํฅ ๋ฒกํฐ๋ก์ ์ด์ฉํด์ผ๋ ํ๋์ ๋ฒกํฐ๋ฅผ ์ป๋๋ค.
... ํ ํ . ๋ญ์๋ฆฐ์ง. ๋๋ ์์ง~
๊ณต์]
http://zp.cse.cau.ac.kr/~erunc0/study/d3d/potential.bmp
์ฅ์
์ฐ๋ฆฌ๋ ๋ช ๋ฒฝํ๊ฒ ์ฅ์ ๋ฌผ 2๋ณด๋ค๋ ์ฅ์ ๋ฌผ 1์ ํผํ๊ธฐ๋ฅผ ๋ ์ํ ๊ฒ์ด๋ค.
์ฆ, ์ฅ์ ๋ฌผ 2๋ ํจ์ฌ ๋ ๋ฉ๋ฆฌ ๋จ์ด์ ธ ์๊ธฐ ๋๋ฌธ์ด๋ค.
~cpp -------------- | obstacle 2 | | goal | -------------- -------------- | obstacle 1 | -------------- |creature.|์ฐ๋ฆฌ๋ ์ด ์์ ์ ํ๋์ ๋ฑ์์ผ๋ก ๋ฐ๊ฟ ์ ์๋ค. ์ต์ด ์ฐ๋ฆฌ์ ๋ฐฉํฅ์
๋ชฉํ ์ง์ ์ ํฅํ ํ๊ท ํ๋ ๋ฒกํฐ์ด๋ค(or ๋ชฉํ ์ง์ ์ ์์น์์ ํ์ฌ ์์น๋ฅผ ๋บ ๊ฒ)
๊ทธ๋ฆฌ๊ณ , ๊ฐ๊ฐ์ ์ฅ์ ๋ฌผ์ ๋ํด ๊ณง์ฅ ๋๋ง๊ฐ ์ ์๋๋ก ํ๋ ํ๊ท ๋ฒกํฐ๋ฅผ ์ฐพ์๋ธ๋ค.
์ด ํ๊ท ๋ฒกํฐ๋ฅผ ํ๋์ ์์๋ก ๊ณฑํ ๋ค์ ๋ค์ ์ฅ์ ๋ฌผ๋ก๋ถํฐ์ ๊ฑฐ๋ฆฌ์
์ ๊ณฑ์ผ๋ก ๋๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋์๋ ๋ฌผ์ฒด๊ฐ ๋ฐฉํฅ ๋ฒกํฐ๋ก์ ์ด์ฉํด์ผ๋ ํ๋์ ๋ฒกํฐ๋ฅผ ์ป๋๋ค.
... ํ ํ . ๋ญ์๋ฆฐ์ง. ๋๋ ์์ง~

๊ณต์]
http://zp.cse.cau.ac.kr/~erunc0/study/d3d/potential.bmp
~cpp // ์ค์ ์ฌ์ฉ ์. bool Process() { point3 goalVec = g_goalLoc - m_loc; if( goalVec.Mag() < g_creatureSpeed ) return false; // goal๊น์ง ๋์ฐฉํ๋ค. point3 dirVec = goalVec / goalVec.Mag(); float k = .1f; // ๊ฐ๊ฐ์ obstacle๊ณผ ๊ฒ์ฌ for( int i=0; i<g_obstacles.size(); i++ ) { // creature์์ obstacle๊น์ง์ vector point3 obstacleVec = m_loc - g_obstacles[i].m_loc; // obstacle๊ณผ creature์ฌ์ด์ ์ค์ ๊ฑฐ๋ฆฌ float dist = obstacleVec.Mag() - g_obstacles[i].m_rad - m_rad; // this is the vector pointing away from the obstacle ?? obstacleVec.Normalize(); dirVec += obstacleVec * ( k / (dist * dist) ); // creature๋ฅผ ํํ์ด๋ ์ํฌ ํ๋ ฌ์ ์ป๋๋ค. ๋ชจ๋ obstacle์ ๊ฒ์ฌ ํ๋ฉด์... } dirVec.Normalize(); m_loc += g_creatureSpeed * dirVec; return true; // ok. obstacle์ ํผํ๋ค. }์คํ ํ์ผ: http://zp.cse.cau.ac.kr/~erunc0/study/d3d/potentialFunc.exe
์ฅ์
- ์ผ์ธ์ ๊ฒฝ์ฐ์ ๊ฐ์ ๋ฌผ๋ฆฌ์ ์ฅ์ ๋ฌผ์ด ๋๋ฌธ ๊ฒฝ์ฐ์๋ ์๋๋ค.
- ์ฅ์ ๋ฌผ๋ค์ด ์ค์ค๋ก ์์ง์ผ ์๋ ์๋ค๋ ๊ฒ.
- ์ฅ์ ๋ฌผ๋ค์ด ๋๋ฌด ๊ฐ๊น์ด ๋ฐ์งํด์ ๋ถ์ด ์๋ค๋ฉด ๊ทธ๊ฒ์ ๋น ์ ธ ๋์ฌ์ ์๋ค.