์์ฑ์: ๊น์ํ(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์ฅ์
- ์ผ์ธ์ ๊ฒฝ์ฐ์ ๊ฐ์ ๋ฌผ๋ฆฌ์ ์ฅ์ ๋ฌผ์ด ๋๋ฌธ ๊ฒฝ์ฐ์๋ ์๋๋ค.
- ์ฅ์ ๋ฌผ๋ค์ด ์ค์ค๋ก ์์ง์ผ ์๋ ์๋ค๋ ๊ฒ.
- ์ฅ์ ๋ฌผ๋ค์ด ๋๋ฌด ๊ฐ๊น์ด ๋ฐ์งํด์ ๋ถ์ด ์๋ค๋ฉด ๊ทธ๊ฒ์ ๋น ์ ธ ๋์ฌ์ ์๋ค.
