아자!

깊이 버퍼 쉐도우 맵이라는거 정말 좋은 그림자 기법입니다.

첫째 구현하기 간단하고.. 둘째 간단함에도 불구 하고 자기그림자까지 표현하는 정교함까지..

그런데 장점이 좋은 만큼 단점도 눈에 확 들어오는데요.

1. Z Fighting 에 의한 Moire 발생.

2. 넓은 영역을 커버 할때 나타나는 엄청 거슬리는 깍뚜기(알리아싱)들.

그래서 여러방법이 나오는데

PSM (Perspective Shadow map), LisPSM(Light Space Perspective Shadow map), TSM(Trapezoidal Shadow Maps).. 등등등..

그래서 검색을 해보면 별 해괴 망측한 수식들과 그림들이 튀어나옵니다.

뭐 이런 그림들이지요. 저는 당최 모르겠습니다.

대학교에서 4년이나 물리학을 배웠는데도 도데체가 뭔소린지.. 뷰프러스텀 짜부려놓고 저게 무슨 논문이라고.. 지들은 알아보는건지..

남들은 잘정리된 논문이라고 하던데.. 난 머리가 나쁜것인지..

그래서 그냥 제가 만들기로 했더랬지요.

먼저 아주 전통적인 깊이버퍼 그림자를 구현 해보면..

이렇게 나옵니다.. 180m X 180m를 그림자 한장으로 덮었더니 이꼴이 났는데요.

그림자의 해상도는 자그마치 2048X2048 짜립니다.

예.. 멀리 있는건 볼만 하지만 앞에 있는 그림자는 정말 못봐주겠더랩니다.

2048이라는 해상도는 다 어따가 팽개친건지..

다음 그림이 어따가 팽개쳤는지 알려줍니다.

개략적으로 그린것이긴 하지만 대충 봐도 낭비가 엄청 심하다는것을 알수 있구요.

2048이면 뭐합니까 앞에서는 40~200 픽셀 정도 밖에 못쓰는데..
..

..

..
그럼 다음 그림을 보면..

오오.. 앞에 그림과 거의 같은 위치에서 보는 것이지만 틀려도 너무 틀립니다.

물론 해상도는 되려 작습니다. 1024X1024를 쓰고 있습니다.

어떻게 이런일이 가능해 버린걸까요?

깊이버퍼를 보면 다음과 같습니다.

역시 대충 그린 그림입니다. 하지만 뭔가 틀리지요?

네. 카메라와 가까운곳은 크게 그려주고 먼곳은 작게 그려주는것. 그게 포인트 입니다.

낭비되는 범위는 비슷하지만 그려지는 화질이 틀린것이지요.

PSM의 공통된 의도는 바로 그겁니다. 가까운곳에는 텍스처의 픽셀을 많이 할당하고 먼곳은 적게 할당한다.

간단하지요?

그런데 그 수식 구할라고 하면 아주 박터집니다. 도데체 뭔말인지도 모르겠고 수식은 뭔 기호가 그렇게 많은지..

물론 위에 제가 직접 사용한 방식은 PSM의 의도만을 가지고 순수하게 제가 그냥 코딩한 것이라서 내세우긴 좀 뭐합니다만....

저와 마찬가지로 그냥 PSM의 맛보기라도 하고싶다라는 분들이 있을꺼라 생각하고..

또 제가 알고 있는 이 방법이 의외로 다른 분들에게 도움이 될지도 모른다는 생각에 씁니다.

[시작.]

먼저 전통적인 깊이 버퍼 그림자의 순서입니다.

1. 깊이텍스처를 준비한다.

2. 렌더 타겟을 깊이텍스처로 전환

3. 광원의 위치로 View행렬을 세팅(단. Up Direction은 카메라가 보는 방향)

4. 광원의 FOV대로 Projection행렬 세팅

5. 깊이값을 렌더링

6. 렌더 타겟을 다시 주버퍼로 전환

7.  카메라의 위치로 View행렬 세팅

8. 카메라의 FOV대로 Projection 행렬 세팅

9. 3과4에서 쓰인 행렬식을 토대로 깊이 버퍼를 가져와 비교하여 그림자 채색.

- 2로 다시 반복.

...

이건데요.

제가 사용한 방법은 위의 전통적인 방법과 순서는 전혀 안틀립니다.

아니.. 아예 똑같습니다.

하지만 코드상에서 틀린부분은 바로 4번(광원의 FOV대로 Projection행렬 세팅) 인데요.

일단 똑깉이 구해놓고 행렬하나를 더 만들어서 곱한후에 세팅합니다.

그 행렬이 뭔고 하면 그림을 위에 보시는 것처럼 짜부러 뜨리는 행렬입니다. (아래는 넓게 위쪽은 좁게)

어떻게?

바로 우리가 알고 있는 카메라 프로젝션 행렬을 곱해주는 겁니다. 근데 그냥 곱하면 안되구요.

..

..

프로젝션 행렬을 통하고 나면 좌우 위아래는 -1~1 로 고정되구요 앞뒤는 0~1로 고정됩니다.

원래 프로젝션 행렬은 앞은 크게 뒤는 작게 그릴수 있게 해주는 것입니다.

-Z 축으로 왜곡

그런데 우리는 위는 좁게 아래는 크게 만들어줘야 합니다.

-Y 축으로 왜곡

감이 오시지요?

우리가 가장 많이 쓰는 프로젝션 행렬은 Dx에서 다음과 같이 정의 됩니다.

2*zn/w  0          0                   0
0           2*zn/h  0                   0
0           0          zf/(zf-zn)       1
0           0          zn*zf/(zn-zf)  0

w는 뷰 프러스텀의 폭

h는 뷰 프러스텀의 높이

zn은 근단면의 거리

zf는 원단면의 거리입니다.

앞에서 말한것과 같이 Z축 왜곡이니까 Y축 왜곡으로 바꿔볼잡시면

2*zn/w  0                     0            0
0           zf/(zf-zn)        0             1
0           0                    2*zn/h     0
0           zn*zf/(zn-zf)   0             0

이렇게 됩니다.

이걸 4번에서 구한 프로젝션 행렬에 곱해준다음 적용하는 겁니다.

간단하죠?

하다못해 셰이더 코드는 100% 똑같습니다.

w는 원래 같으면 다른 값을 쓰겠지만 1 이하가 됩니다. 이미 프로젝션 행렬을 통한 다음엔 최대 좌우 폭은 -1~1 2가 되기때문이지요.

w와 h는 근단면의 폭과 높이이기 때문에 2보다는 작아지니까요.

그리고 zn과 zf는 모두 0~1 사이값을 갖게 됩니다. zf는 1보다 더 커져도 큰 무리는 없지만 zn은 정말 세밀하게 조절 해야됩니다.

zn값 하나 때문에 퀄리티가 오르락 내리락 합니다. 너무 작으면 깍뚜기가 나오고 너무크면 가까운곳은 그림자가 사라집니다.

테스트를 거쳐야 나오는 값이라 뭐라 포스팅 할수가 없네요.

이 방법도 단점은 있습니다.

바로 라이트의 방향과 카메라의 방향의 각에 따라 퀄리티가 들쭉 날쭉 합니다.

이는 좀더 그림자맵을 그릴때 방향을 잘 잡아야 하는 문제니까 금방 잡힐꺼 같습니다.

최종적으로 모든게 적용된 스크린샷을 올려 볼께욤.

갑자기 만든거 치고는 괜찮아보여 혼자 만족중입니다. 하하핫!

/////////////////////////////////////////////////////////////////////////////////
float4x4 mLightSpaceWvp;
float4x4 mWvp;
float4x4 mObjWorld;

float4 LightAmbient = {0.1, 0.1, 0.1, 1};
float4 LightDiffuse = {1, 1, 1, 1};
float4 LightDirInv;
float4 LightPos;

/////////////////////////////////////////////////////////////////////////////////
#include "../common/afx_texture_macro.fxh"

TEXTURE_2D( txrDepthMap, sampDepthMap, Clamp, NONE, LINEAR, LINEAR)
TEXTURE_2D( txrTerrain, sampTerrain, Wrap, LINEAR, LINEAR, LINEAR)

/////////////////////////////////////////////////////////////////////////////////
// Render Depth from Light
struct vso_RenderDepthMap
{
float4 HPosition : POSITION;
float4 LightSpacePos : TEXCOORD0;
};

vso_RenderDepthMap VS_RenderDepthMap(float3 pos : POSITION)
{
vso_RenderDepthMap o = (vso_RenderDepthMap)0;

float4 Pos = {pos, 1};
o.HPosition = mul(Pos, mLightSpaceWvp); // 라이트위치로부터의 깊이값을 저장하기 위해.
// 실제 필요한 건 (깊이맵을 그리기위한)z 값.
o.LightSpacePos = o.HPosition / o.HPosition.w; // 프로젝션을 거치면서 값이 w로 정규화되지 않는 경우를 위해 표준회
return o;
}
float4 PS_RenderDepthMap(float4 LightSpacePos : TEXCOORD0 ) : COLOR0
{
//LightSpacePos /= LightSpacePos.w; // 픽셀셰이더에서 정규화하면 좀더 세밀하겠지만 별 차이없음.
return (float4)LightSpacePos.z; // 깊이맵 그리기. 캐릭터가 이동할때마다 재계산되어 깊이맵도 변함.
// 모든 오브젝트에 그림자가 생김.
}

/////////////////////////////////////////////////////////////////////////////////
// Render Terrain
struct vso_RenderTerrain
{
float4 HPosition : POSITION;
float2 t : TEXCOORD0;
float4 LightSpacePos: TEXCOORD1;
};
vso_RenderTerrain VS_RenderTerrain(float3 pos:POSITION, float2 t:TEXCOORD0)
{
vso_RenderTerrain o = (vso_RenderTerrain)0;

float4 Pos = float4(pos,1);
o.HPosition = mul( Pos, mWvp);
o.t = t;

float4 PosLWvp = mul( float4(pos,1), mLightSpaceWvp);

PosLWvp /= PosLWvp.w; // for range ( -1 ~ 1 )
o.LightSpacePos.x = PosLWvp.x*0.5 + 0.5;
o.LightSpacePos.y = -PosLWvp.y*0.5 + 0.5;
o.LightSpacePos.z = PosLWvp.z;
o.LightSpacePos.w = PosLWvp.w;

return o;
}
float4 PS_RenderTerrain(float2 t:TEXCOORD0, float4 LightSpacePos:TEXCOORD1) : COLOR0
{
float4 addc = (float4)0.1;
float4 col1 = tex2D(sampTerrain, t)+addc;
float4 col2;
// 깊이값 비교.
// 0.03 는 오차보정용.
if( LightSpacePos.z-0.03 > tex2D(sampDepthMap, LightSpacePos.xy).z) col2 = (float4)0.3;
else col2 = (float4)1.0;

return col1*col2;
}
// ///////////////////////////////////////////////////////////////////////////////
struct vso_Object
{
float4 HPosition : POSITION;
float4 Normal : TEXCOORD0;
};
vso_Object VS_RenderObj( float3 pos : POSITION, float3 Normal:NORMAL )
{
vso_Object o = (vso_Object)0;
o.HPosition = mul(float4(pos, 1), mWvp );
o.Normal = float4( mul(Normal,(float3x3)mObjWorld), 0);
return o;
}

float4 PS_RenderObj(float4 Normal : TEXCOORD0) : COLOR0
{
float4 o = (float4)0;
float4 N = normalize(Normal);
float4 L = normalize(LightDirInv);
float ldn = max( dot(N, L), 0 );
o = LightAmbient + LightDiffuse * ldn ;
return o;
}
/////////////////////////////////////////////////////////////////////////////////
technique DepthShadow
{
// Render Shadow to Texture
pass P0
{
VertexShader = compile vs_2_0 VS_RenderDepthMap();
PixelShader = compile ps_2_0 PS_RenderDepthMap();
}
pass P1
{
VertexShader = compile vs_2_0 VS_RenderTerrain();
PixelShader = compile ps_2_0 PS_RenderTerrain();
}
pass P2
{
VertexShader = compile vs_2_0 VS_RenderObj();
PixelShader = compile ps_2_0 PS_RenderObj();
}
}

포인터? 생각만 하면 머리가 아파오는 녀석이죠..C 언어로 생계를 유지해온 저로서도 복잡한 포인터를 보면 피하고 싶습니다..이런 포인터 인데 함수포인터라니? 이건 뭐 대마왕급이군요...

그런데 이런 대마왕도 상황에 따라, 그리고 고급프로그래밍을 위해서 간간히 써주어야만 하는 돌발상황이 발생하곤 합니다..어쩔수 없는 운명이죠..TT

피할수 없다면 한번 부딪혀 보는 건 어떨까요? 기초 개념만 잡으면 너무 쉽다(?)고 느끼실 겁니다..자, 그럼 기본부터 한번 시작해 보겠습니다..

우선 다음과 같은 코드를 보죠..아주 단순한 코드입니다..

-----------------------------------------------------------------------------------

main()

{

int a = 10;

int* b = &a;

...

...

}

-----------------------------------------------------------------------------------

변수 a 에 10을 대입하고 변수 b 에는 a 의 주소값을 저장합니다. 그럼 여기서 질문하나 해볼까요? 변수 a 와 b 는 어디에 존재할까요? CPU ? 하드디스크 ? 아님 메모리?

모두 아시겠지만 변수는 메모리, 정확히 말하면 RAM 에 존재합니다. 아래 그림에 간략히 나타내보았습니다.

그럼 다음 코드를 한번 보겠습니다..좀전보다 조금 어렵습니다..(???)

-----------------------------------------------------------------------------------

void func(int x)

{

printf("x = %d\n",x);

}

main()

{

int a = 10;

int* b = &a;

func(a);

}

-----------------------------------------------------------------------------------

이번에는 함수 func 라는 놈이 등장했네요..여기서 다시 질문하나 할께요..변수는 RAM 에 저장되는데 그럼 함수 func 는 어디에 저장될까요? 또 main 도 특별한 함수죠..즉, 시작할때 제일 먼저 불리는 함수..이런 함수들은 도대체 어디에 존재하는걸까요????

함수는 변수와 마찬가지로 RAM 에 저장되어 있습니다...왜냐면 실행되는 모든 프로그램은 RAM 에 저장되어야 하는데 함수도 프로그램의 일부이니까요..그림으로 나타내 볼까요..

위 그림처럼 RAM 의 어딘가에 func 라는 함수부분이 저장되어 있습니다. RAM에는 언제나 주소가 있죠? 예를 들어 변수 a 는 &a 라는 주소에 있고 변수 b 는 &b 라는 곳에 있습니다. 그럼 func 는 어디에 있을까요?

주소를 나타내려면 & 를 붙인다고 했으니 &func? 아님 임의의 다른곳??

C 언어에서 함수가 저장되어 있는 주소값은 바로 함수 이름입니다. 즉, 함수이름이 함수가 저장되어 있는 첫번째 번지를 나타냅니다. (마치 배열과 비슷합니다. 배열 이름이 배열의 시작주소를 나타내는 것처럼요..) 그래서 func 라는 함수가 저장되어 있는 번지는 func 이고, main 함수가 저장되어 있는 번지는 main 입니다..(많이 헛갈리시죠..예전에 제가 그랬습니다...)

이제 함수가 저장되어 있는 주소값을 알았으니 그 값을 저장할수 있는 변수도 있어야겠죠..이렇듯 함수가 저장되어 있는 주소값을 저장할수 있는 변수를 '함수포인터' 라고 합니다. 즉, 함수포인터는 함수의 이름을 가지는 변수입니다..

그럼 함수이름을 저장할수 있는 변수는 어떻게 선언하고 초기화 할까요? 다음의 소스를 한번 보죠..

-----------------------------------------------------------------------------------

void func(int x)

{

printf("x = %d\n",x);

}

main()

{

int a = 10;

int* b = &a;

void (*test)(int);

test = func;

func(a);

}

-----------------------------------------------------------------------------------

우선 'void (*test)(int);' 부분입니다. 해석을 해보면 test 라는 변수는 인자로 한개의 정수(-int-) 를 가지고 반환형이 없는 (-void-) 함수를 가리키는 포인터이다 입니다. 이렇게 선언된 test 라는 변수에 func, 즉 func 가 저장되어 있는 주소값(-함수이름-)을 대입하는 곳이 소스에서 'test=func' 입니다. (func 함수가 인자로 정수한개를 받고 반환형은 없죠..확인해보세요)

그림을 통해 이해해보죠..

이제 마지막으로 함수포인터를 통해 함수가 어떻게 호출되는지 알아보겠습니다..소스코드에서 변수 포인터 b 를 통해 a 를 접근하고자 할때 '*b' 라고 기술했습니다. 그럼 함수포인터는 ? 함수포인터도 변수 이므로 *b 처럼 * 연산자를 이용해 함수를 접근할수 있습니다.다음의 코드를 보면서 결과값이 같다는 것을 확인해보시기 바랍니다...코드에서 (*test)(a) 의 해석은 다음과 같다고 할수 있습니다. 'test 라는 변수가 가리키는 곳에다 a 값을 넘겨준다'

-----------------------------------------------------------------------------------

void func(int x)

{

printf("x = %d\n",x);

}

main()

{

int a = 10;

int* b = &a;

void (*test)(int);

test = func;

func(a);

(*test)(a);

}

-----------------------------------------------------------------------------------

어떠신가요? 함수포인터라고 무시무시한 이름을 가지고 있지만 막상 별것 없죠..이런 함수포인터는 속도가 중요시되거나 그래픽관련 프로그래밍을 구현하고자 할때 가끔 쓰입니다. 또한 커널 프로그래밍을 할때도요..그러나 기본에 충실하시면 어렵지 않게 이해 할수 있을거라 믿습니다..

(이제 함수 포인터는 대마왕의 자리를 내주고 쓸쓸히 은퇴해야겠네요..)

다음의 예제를 한번 풀어보시고 이해해 보시기 바랍니다...(다음주제는 네트웍프로그래밍을 진행해 볼까 합니다..많은 응원부탁 ^^..)

언제나 즐거운 시간만 되세요...

[1] int (*fPtr1)(int); [이해난이도 : 하]

[2] int (*fPtr2)(int, int); [이해난이도 : 하]

[3] void (*signal(int, void(*handler)(int)) ) (int); [이해난이도 : 최상]

기본적인 파일 관리함수

int _access( const char *path, int mode );

파일을 엑세스 하기 전에 파일이 실제로 존재하는지 확인하는 함수입니다.

path : 조사할 파일의 경로

mode: 조사할 상태 지정 ( 0 은 존재, 2 는 쓰기, 4 는 읽기 )

return : 요청한 허가 상태를 가지면 0을 리턴, 그렇지 않으면 -1을 리턴

int remove( const char *path );

int _unlink( const char *filename );

위의 두 함수는 파일을 삭제 합니다.

path : 삭제하고자 하는 파일의 경로만 지정

int rename( const char *oldname, const char *newname );

이 함수는 파일의 이름을 변경합니다.

oldname : 변경하고자 하는 파일의 이름

newname : 새로 설정할 파일의 이름

int _chmod( const char *filename, int pmode );

파일의 속성을 변경 합니다.

pmode : _S_IWRITE  ,  _S_IREAD  둘중 하나를 주거나 둘다 줄수도 있음

파일검색 함수

long _findfirst( char *filespec, struct _finddata_t *fileinfo );

위의 함수로 첫번째 파일 검색 합니다.

int _findnext( long handle, struct _finddata_t *fileinfo );

위의 함수로 조건이 일치하는 다음 파일을 찾을수 있습니다.

int _findclose( long handle );

위의 함수로 모든 검색이 완료된 후 검색 핸들을 닫아 줍니다.

디렉토리 관리 함수

int _chdir( const char *dirname );

현제 작업중인 디렉토리의 경로 변경

char *_getcwd( char *buffer, int maxlen );

현재 작업 디렉토리를 조사

int _mkdir( const char *dirname );

디렉토리 생성

int _rmdir( const char *dirname );

디렉토리 제거

void _splitpath( const char *path, char *drive, char *dir, char *fname, char *ext );

경로 관리 함수로서  4개의 구분자로 분리한다.

void _makepath( char *path, const char *drive, const char *dir, const char *fname

                              , const char *ext );

경로 관리 함수로서 분리되어 있는 구분자를 합친다.

디스크 관리 함수

int _getdrive( void );

int _chdrive( int drive );

위의 두 함수는 작업 드라이브를 조사하거나 변경한다.

ShellExecute(NULL, "open", http://naver.com, "", "", SW_SHOW );

내장 되어 있는 기본 웹 브라우저를 뜨우는 방법

ShellExecute(NULL, "open",

"C:\\Program Files\\InternetExplorer\\IExplorer.exe", 

"http://naver.com",
"",
SW_SHOW
);

인터넷 익스플로러를 지정하여 띄우는 방법