Knowledge Base

Bidirectional Reflectance Factor
Reflectance
Backscatter (optical)
Illumination Angle
Radiance
Viewing Angle

Equation 1:

Equation 2:

Graphic 1:

Illumination and reflectance geometry.
R = reflected radiation,
I = incident radiation;
N = north;
S = south;
Z = vertical direction
, = viewing angle
, = illumination angle

GPU들이 더 빠르게 성장함에 따라, GPU에 친숙한 알고리즘들은 더욱 대중적인 것이 되었습니다. 따라서 다른 쉐도우 기법들과 비교하여, 쉐도우 맵핑은 아마도 그림자들을 생성하기 위해 가장 광범위하게 사용되는 기법일 것입니다. 이 글은 전방향성 라이트들 (Omni-directional lights)을 위한 쉐도우 맵핑에 대한 구현의 기본적인 것들을 살펴볼 것이고 최적화와 기법의 향상을 위한 몇몇 이론들을 제공할 것입니다. 다른 접근법들과 방법들이 존재하기 때문에, 저는 최적화의 자세한 부분들을 처리하도록 시도하지 않을 것입니다. 또한, 독자가 C++과 Direct3D의 기본적인 내용과 기본적인 쉐도우 맵핑 기법들에 친숙하다고 가정합니다.

The Algorithm

Implementation

Step 1 : Initialization

m_pd3dDevice->CreateCubeTexture(m_iCubeFaceSize, // Cube face edge length
1, // mip levels
D3DUSAGE_RENDERTARGET,
D3DFMT_R32F,  // could be D3DFMT_R16F
D3DPOOL_DEFAULT,
&m_pCubicShadowTex,
NULL);

cubicShadowMap->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &depthCubeFacePX);

D3DXMatrixPerspectiveFovLH(&m_ProjMat, D3DX_PI / 2.0f, 1.0f, 1.0f, 500.0f);

Step 2 : Rendering to the cubic shadow map

큐빅 쉐도우 맵에 장면의 깊이를 렌더링하기 위해, 우리는 이전 단계에서 설명된 가상 카메라를 사용할 것입니다. 이 카메라의 방향은 매 단계에서, 각 단계에서 카메라의 뷰 벡터를 변경하고 그에따라 뷰 행렬이 갱신되어져야만 한다는 것을 의미하는 양의 X, 음의 X, 양의 Y, 기타 등등을 바라보도록 변경될 것입니다.

그림 1 : 큐빅 쉐도우 맵에 장면의 깊이를 렌더링하기 위해 6개의 방향들에서 라이트의 카메라.

따라서, 처음 단계를 위해 우리는 다음과 같이 해야 합니다 :

1. 카메라를 양의 X 축을 바라보도록 설정합니다.
2. 초기화 단계에서 얻은 적절한 큐브 면에 렌더 타겟을 설정하고 삭제합니다.
3. 장면 깊이를 렌더링 합니다 (스팟 라이트 쉐도우 맵핑에서 깊이를 렌더링하는 것과 동일합니다).

두번째 단계를 위해 다음과 같이 해야 합니다 :

1. 카메라를 양의 Y 축을 바라보도록 설정합니다.
2. 초기화 단계에서 얻은 적절한 큐브 면에 렌더 타겟을 설정하고 삭제합니다.
3. 장면 깊이를 렌더링 합니다 (스팟 라이트 쉐도우 맵핑에서 깊이를 렌더링하는 것과 동일합니다).

계속 합니다.

큐빅 쉐도우 맵 면에 장면 깊이를 렌더링하는 것은 일반적인 쉐도우 맵핑과 동일합니다. 우리는 카메라를 사용하고 우리의 타겟이 2D 소수점 텍스쳐입니다. 여기에 이 부분을 위한 작업을 하게 될 버텍스 쉐이더가 있습니다 :

VS_OUTPUT_DEPTH DepthMap_VS(float4 inPosition : POSITION)
{
VS_OUTPUT_DEPTH output;
 
float4 positionW = mul(inPosition, worldMat);
output.oPositionLight = mul(inPosition, worldViewProjMat);
 
output.lightVec = lightPosition - positionW.xyz;
 
return output;
}

픽셀 쉐이더는 단지 HLSL의 명령 함수를 사용하여 라이트 벡터의 길이를 계산할 것이고, 출력물들은 파이프라인의 결과입니다.

다음의 C++ 코드는 구현의 두번째 단계를 위한 작업을 하게 될 것입니다 :

// enable red channel for color write
m_pd3dDevice->SetrenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED);
 
m_pShadowEffect->m_pEffect->SetTechnique(m_pShadowEffect->m_DepthMapHandle);
m_pShadowEffect->m_pEffect->Begin(&numOfpasses, NULL);
 
// render the scene depth to positive X side of the cube map
createCamForPositiveX();  // a helper function for setting up the light's camera looking toward positive X axis
renderDepthToCubeFace(depthCubeFacePX);
 
// render the scene depth to positive Y side of the cube map
createCamForPositiveY();
renderDepthToCubeFace(depthCubeFacePY);
 
// render the scene depth to positive Z side of the cube map
createCamForPositiveZ();
renderDepthToCubeFace(depthCubeFacePZ);
 
// render the scene depth to negative X side of the cube map
createCamForNegativeX();
renderDepthToCubeFace(depthCubeFaceNX);
 
// render the scene depth to negative Y side of the cube map
createCamForNegativeY();
renderDepthToCubeFace(depthCubeFaceNY);
 
// render the scene depth to negative Z side of the cube map
createCamForNegativeZ();
renderDepthToCubeFace(depthCubeFaceNZ);
 
m_pShadowEffect->m_pEffect->End();
 
// enable color writes
m_pd3dDevice->SetRenderState(D3DRS_COLORWRITEENABLE,
D3DCOLORWRITEENABLE_ALPHA |
D3DCOLORWRITEENABLE_RED |
D3DCOLORWRITEENABLE_GREEN |
D3DCOLORWRITEENABLE_BLUE);

renderDepthToCubeFace(…)와 createCamFor…() 함수들에 대한 코드들 입니다 :

void CCubicShadowMapping::renderDepthToCubeFace(LPDIRECT3DSURFACE9 inCubeSurface)
{
D3DXMATRIXA16 worldViewProjMat;
 
// set and clear the cube map face surface
if (SUCCEEDED(m_pd3dDevice->SetRenderTarget(0, inCubeFaceSurface)))
{
m_pd3dDevice->Clear(NULL, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, NULL);
}
 
// render all geometries of the scene (assuming that there is no scene management or frustum culling algorithm)
}
 
void CCubicShadowMapping::createCamFor***()
{
m_pLightCamera->setLook(/*m_PositiveLookX for example*/);
m_pLightCamera->setUp(/*m_PositiveLookY for example*/);
m_pLightCamera->setRight(/*m_NegativeLookZ for example*/);
 
// update the camera's concatenated view-projection matrix with new look, up and right vectors
m_pLightCamera->updateViewProjMat();
}

우리가 R32F 텍스쳐 포맷을 가지고 단지 레드 채널만이 사용되기 때문에, 거의 대부분 본질 적으로우리의 큐브 텍스쳐에 장면 깊이를 렌더링 할 때 레드 채널은 있지만 색상들을 쓰기는 비활성화 됩니다. 왜냐하면 큐빅 쉐도우 맵들은 큰 텍스쳐들이어서, 우리는 이 기법을 사용할 때 필-레이트 문제들을 고려해야 합니다. 예를들어, 512 픽셀들의 경계 크기인 큐빅 쉐도우는 비디오 메모리에서 6 (면) * 262,144 (픽셀들) * 32 bit = 6144KB를 차지 합니다. 이것이 기법의 처음 부분을 구현하는데에 여러 최적화 기법들이 존재하는 가에 대한 이유입니다 (큐빅 쉐도우 맵의 색성). 당신은 이러한 퍼포먼스 향상 기법들에 친숙하도록 “최적화” 부분을 참조할 수 있습니다.

Step 3 : Rendering the Scene using cubic shadow map

큐빅 쉐도우 맵을 가지게 된다면, 이제 우리의 큐브 맵내의 대응하는 픽셀들과 각 픽셀의 깊이 비교를 하게 될 마지막 단계를 구현할 시간이 됐습니다. 현재 픽셀의 깊이가 큐빅 쉐도우 맵에서 샘플링된 깊이 보다 크다면, 픽셀은 그림자가 드리워 진것이고, 아니라면 빛을 받게 되는 것입니다. 알고리즘에서 언급했듯이, 투영 텍스쳐에 사용되는 것이 샘플링된 2D 텍스쳐라는 것 대신 샘플링한 큐브 맵이라는 것만이 차이점입니다.

큐브 텍스쳐의 샘플링은 세가지 구성 벡터가 요구됩니다. 이것을 위해, 우리는 라이트의 위치에서 현재 픽셀을 가리키는 곳에서 시작되는 라이트의 방향 벡터의 역을 사용합니다. 우리가 큐브 맵에 각 픽셀의 깊이를 렌더링하는 곳에서, 깊이 요소에 따라 라이트 벡터의 길이가 사용되는 것을 기억하십시요. 그래서 여기서 우리는 깊이 비교를 하기 위해 샘필링하는 우리의 큐브 맵과 현재 픽셀의 깊이를 위한 동일한 것을 하게 될 것입니다. 다음의 HLSL 코드는 장면의 그림자와 라이팅을 계산하게 되는 이펙트에서 추출된 함수입니다 :

lightFuncOutput LightPositionSH(float3 inObjPos, float3 inNormal, float3 inCam2Vertex)
{
lightFuncOutput output;
output.diffuseResult = float4(0.0f, 0.0f, 0.0f, 1.0f);
output.specularResult = float4(0.0f, 0.0f, 0.0f, 1.0f);
 
float4 PLightDirection = 0.0f;
PLightDirection.xyz = lightPosition.xyz - inObPos;    // inObjPos is the pixel's position in world space
float distance = length(PLightDirection.xyz);    // the depth of current pixel
PLightDirection.xyz = PLightDirection.xyz / distance;
 
// compute attenuation factor
PLightDirection.w = max(0, 1 / (lightAttenuation.x +
lightAttenuation.y * distance +
lightAttenuation.z * distance * distance);
 
// sample the cubic shadow map using the inverse of light direction
float shadowMapDepth = texCUBE(cubeShadpwMapSampler, float(-(PLightDirection.xyz), 0.0f)).x;
 
// do the depth comparison
if (distance > shadowMapDepth)
{
return output;    // the pixel is in shadow so only the ambient light is visible to eye
}
else
{
// the pixel is not in shadow so the phong lighting is applied
float3 floatVecTmp = normalize(inCam2Vertex + PLightDirection.xyz);
 
output.diffuseResult = PLightDirection.w * lightDiffuse * max(0, dot(inNormal, PLightDirection.xyz));
output.specularResult = PLightDirection.w * lightSpecular * pow(max, dot(inNormal, floatVecTmp)), specPower);
 
return output;
}
}

그리고 최종적으로 이 단계의 버텍스와 픽셀 쉐이더는 다음과 같습니다 :

VS_OUTPUT cubicShadowMapping_VS(float4 inPosition : POSITION, float3 inNormal : NORMAL)
{
VS_OUTPUT output;
 
float4 positionW = mul(inPosition, worldMat);
 
output.cam2Vert = (eyePosition - PositionW).xyz;
output.position = mul(inPosition, worldViewProjMat);
output.worldPos = positionW.xyz;
output.normalW = mul(inNormal, worldMat).xyz;
 
return output;
}
 
float4 cubicShadowMapping_PS(VS_OUTPUT In) : COLOR 0
{
lightFuncOutput lightResult;
 
float3 normal = nromalize(In.NormalW);
float3 cam2Vert = normalize(In.cam2Vert);
 
lightResult = LightPointSH(In.worldPos, normal, cam2Vert);
 
float4 ambient = materialAmbient * globalAmbient;
float4 diffuse = materialDiffuse * lightResult.diffuseResult;
float4 specular = materialSpecular * lightResult.specularResult;
 
float4 lighting Color = (ambient + (diffuse + specular));
 
return lightingColor;
}

그림 2 : 전방향성 라이트에서의 최종 결과.

Optimization

The Source code

이 글의 소스 코드에 대해 언급해야하는 몇가지 주의 사항들이 있습니다 :

• 소스 코드는 nVidia PerfHUD에 준비되어 있습니다. 그래서 (만일 당신이 프로그램과 호환되는 비디오 카드를 가지고 있다면) 파이프 라인을 탐색해 보는 것과 실시간으로 알고리즘의 시각화를 보는데 문제가 없습니다. 또한 알고리즘의 속도가 집중되는 부분들을 찾을 수 있고 아마도 새로운 아이디어를 생각해 낼 수 도 있을 것입니다.
• 소스 코드는 최적화되지 않아서 (C++과 HLSL 코드 모두) 당신은 이전에 기술된 최적화 기법들을 위한 코드를 추가 해 볼 수 있습니다.

그림 3 : nVidia PerfHUD로 실행된 예제 어플리케이션.

References

都是非纯2D的texture

cube map  texture可以理解为6个面的纸盒, sample的时候使用vector射线型的sample.

volume texture可以理解是一摞2D texture,sample的时候用第几摞+2D坐标来sample.

虽然都是非2D,sample都用3维数据,差异大啊.

CubeMap 在实时渲染中应用十分广泛. 通过视线和法线计算出的反射光线来查询CubeMap
可以创建一个真实的反射镜面体, 通过视线和法线计算出的折射光线来查询CubeMap
可以创建一个透明体. 由于查询速度快的原因,在实时的CG渲染中应用十分的广泛.

我们的CubeMap大都是从外部的图片得来的, 图片是不可以变化的, 故是静态的.
但问题是, 如果有其他物体在反射物体外运动. 如果我们仅仅查询静态的CubeMap
是不能够反射到动态物体的影象,所以我们需要一个动态的CubeMap, 即我们需要Render to CubeMap.

HLSL에서 noise 함수를 쓰려고 했더니 픽셀 셰이더에서 안된다고 한다. 아얘 안써지는게 아니라... 의존적인 코드가 들어가면 안된다. 예를 들면 노이즈 함수 결과를 이용한다던지 하는거...

ID3DXTextureShader 라는 인터페이스로 사용할 수 있고, 텍스쳐 셰이더를 동작 시키는 방법은

HRESULT D3DXFillTextureTX(
    LPDIRECT3DTEXTURE9 pTexture,
    LPD3DXTEXTURESHADER pTextureShader
);

라는 함수를 사용하면 되는가 보다.
첫 번째 파라메터에는 텍셀이 채워질 텍스쳐 인스턴스이고, 두 번째 파라메터는 텍스쳐 셰이더의 인스턴스... 그리고 HLSL에서 함수 파라메터는 POSITION과 PSIZE가 들어가야 한다. 뭐 POSITION은 텍셀의 좌표이고, PSIZE는 텍셀의 크기. 그리고 반환 값은 당연히 COLOR가 되어야 한다. 텍스쳐 셰이더의 인스턴스를 생성하기 위해서

HRESULT D3DXCreateTextureShader(
    CONST DWORD *pFunction,
    LPD3DXTEXTURESHADER *ppTextureShader
);

를 사용 한단다. 첫 번째 파라메터는 컴파일된 텍스쳐 셰이더의 바이너리 코드 스트림이고, 두 번째는 생성될 텍스쳐 셰이더 인스턴스를 받을 포인터...
컴파일은 D3DXAssembleShader나 D3DXCompileShader등의 함수를 써서 바이너리 코드를 얻어야 하나부다.실시간으로 노이즈 함수를 사용하기 위해서 미리 텍스쳐 셰이더로 노이즈 텍스쳐를 이걸로 만든다음. 정점 셰이더나 픽셀 셰이더에서는 이 텍스쳐를 사용해야 하는 것 같다.

엔비댜에서 이렇다고 한다.

아주 간단한 펄린 노이즈 생성 함수다.

float4 tx_makePerlinNoise(
        float2 vTexCoord : POSITION,
        float2 vTexelSize : PSIZE) : COLOR
{
    float n = 0.0f;
    for (int i = 0; i < 5; ++i)
    {
        n += noise(vTexCoord);
        vTexCoord *= 2.0f;
    }
    n = n * 0.5f + 0.5f;
    return float4(n, n, n, 1.0f);
}

옥타브는 5로 설정해 놓았고, 매 옥타브마다 주파수는 2배씩 증가하도록 해 놓았다.
또한 텍스쳐에는 [0,1) 값만 허용 되므로 (Floating-Point 텍스쳐를 사용하지 않는다면) [-1,1]의 값을 갖는 노이즈 함수를 재 설정 하였다 (<= 뭔 소리야).
위에서 얘기 했지만, vTexCoord : POSITION과 vTexelSize : PSIZE는 필수 항목이다. PSIZE가 있어서 Weighted Sum 연산이 가능할것 같다(추측).

텍스쳐 셰이더를 컴파일 하는 과정에서 약간 애를 먹었는데

HRESULT hRet = D3DXCompileShaderFromFile(
    "perlin_noise.hlsl",
    NULL,
    NULL,
    "tx_makePerlinNoise",
    "tx_1_0",
    0,
    &pTSCodeBuf,
    &pErrMsgs,
    NULL
);

타겟(프로파일)을 tx_1_0 으로 해주어야 한다. 도큐멘트의 함수 설명에는 vs와 ps밖에 안나와 있어서... 나머지 파라메터들은 정점 셰이더와 픽셀 셰이더에서와 같다(모 토큐멘테이션 하기 싫어하는거 공감은 간다).
이렇게 해서 D3DXFillTextureTX로 실행하면 Mipmap 단계들까지 자동으로 채워주는 완벽한 절차적 텍스쳐를 생성할 수 있게 된다. 근데 좀 오래 걸린다. 아무래도 실시간에는 사용 불가능할 듯...

이거 이제 어떻게 써먹냐....

animation controller는 모든 활성화된 track들의 animation을 자동으로 blending해 준다
따라서 animation들을 각 track에 지정하고 track들을 활성화시키면 됨
track을 활성화하기 (Enable을 true로 하면 활성화됨)
 

ID3DXAnimationController::SetTrackEnable
Enables or disables a track in the animation controller.

          HRESULT SetTrackEnable(
            UINT Track,
            BOOL Enable
          );
          Parameters
Track
[in] Identifier of the track to be mixed.
Enable
[in] Enable value. Set to TRUE to enable this track in the controller, or to FALSE to prevent it from being mixed.
Return Values
If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following values: D3DERR_INVALIDCALL, E_OUTOFMEMORY.

Remarks
To mix a track with other tracks, the Enable flag must be set to TRUE. Conversely, setting the flag to FALSE will prevent the track from being mixed with other tracks.

Requirements
Header: Declared in D3dx9anim.h.

각 track의 play 속도를 지정할 수 있음: 보통 1로 하나, fast forward나 slow motion등의 특수효과를 얻으려면 1전후로 조절하면 됨

ID3DXAnimationController::SetTrackSpeed
Sets the track speed. The track speed is similar to a multiplier that is used to speed up or slow down the playback of the track.

          HRESULT SetTrackSpeed(
            UINT Track,
            FLOAT Speed
          );
          Parameters
Track
[in] Identifier of the track to set the speed on.
Speed
[in] New speed.
Return Values
If the method succeeds, the return value is S_OK. If the method fails, the return value can be one of the following values: D3DERR_INVALIDCALL, E_OUTOFMEMORY.

Requirements
Header: Declared in D3dx9anim.h.

// blen함수
void Tiny_X::PlayJogWaveBlend()
{
ID3DXAnimationSet* jog = 0;
ID3DXAnimationSet* wave = 0;
g_animCtrl->GetAnimationSet(JOG_INDEX, &jog);
g_animCtrl->GetAnimationSet(WAVE_INDEX, &wave);
g_animCtrl->SetTrackAnimationSet(0, jog);
g_animCtrl->SetTrackAnimationSet(1, jog);
g_animCtrl->SetTrackWeight(0, 0.4f);
g_animCtrl->SetTrackWeight(1, 0.6f);
g_animCtrl->SetTrackEnable(0, true);
g_animCtrl->SetTrackEnable(1, true);
g_animCtrl->SetTrackSpeed(0, 1.0f);
g_animCtrl->SetTrackSpeed(1, 1.0f);
g_animCtrl->SetTrackPriority(0, D3DXPRIORITY_HIGH);
g_animCtrl->SetTrackPriority(1, D3DXPRIORITY_HIGH);
g_animCtrl->ResetTime();
}
 

  :  전체 애니메이션중에서 중요한 몇개의 프레임에 애니메이션 키 값을 등록하고,

     나머지 들은 자동으로 생성하는 방법이다.

     프레임은 애니메이션에서 출력될 한 장면 한 장면을 말한다.

     자. 이제 밑에 사각형이다.

      (1)                                              (2)

      ◆       ◇       ◇       ◇       ◇       ◆  

 (-10,0,0)                                       (10,0,0) 

   전체 6프레임짜리 애니메이션이라고 치자 ㅡㅡ;;

   꺼먼색 마름모가 처음1번에서부터 2번까지 이동하는 애니메이션이다.

   여기서 키값이라 하면 그 지점에서의 좌표라고 생각하면된다.

   긍까 프레임은 (1)번 프레임 (2)번 프레임 두개만 만들어놓고

   나머지 4개의 중간프레임( ◇ ) 들은 보간(interpolate)하여 자동으로 생성한다.

  책의 예제를 보면 위치가 이동하면서 회전까지 한다.

  크기와 이동은 선형보간으로 해결이 가능하지만..

  회전은.. 사원수를 이용한다.

* 사원수( 쿼터니언(Quaternion) )    :   4개의 값으로 이루어진 복소수체계.. ㅡㅡ;;

   3차원 그래픽에서 회전을 표현할때, 행렬 대신 사용하는 수학적 개념이다.

   행렬에 비해 연산속도도 빠르고 차지하는 메모리의 양도 적다.

   행렬에서는 짐발락(Gimbal Lock) 등 오류가 발생하지만 사원수는 그렇지 않다. 

   암튼 쿼터니언은 회전메트릭스간의 보간을 위해 쓴다.( 중간값을 뽑기위해)

   중간값을 뽑아서 다시 회전 매트릭스로 만들어야 한다. 그래야 쓸 수 있다.

  이넘의 사원수의 수학적 개념은 월욜날 한다고 하였고.. 후...

 - 사원수 관련 함수

 D3DXQuaternionSlerp()                     /// 회전값의 구면선형보간
 D3DXMatrixRotationQuaternion()        /// 사원수를 회전행렬값으로 변환

 소스를 봐보면..

void InitAnimation()  // 애니메이션 초기화 함수
{
 g_aniPos[0] = D3DXVECTOR3( 0, 0, 0 ); /// 위치 키(0,0,0)      // 처음 프레임. (위치값)
 g_aniPos[1] = D3DXVECTOR3( 5, 5, 5 ); /// 위치 키(5,5,5)      // 마지막 프레임.(위치값)

    FLOAT Yaw = D3DX_PI * 90.0f / 180.0f;  /// Y축 90도 회전
    FLOAT Pitch = 0;
    FLOAT Roll = 0;
 D3DXQuaternionRotationYawPitchRoll( &g_aniRot[0], Yaw, Pitch, Roll ); 

                                                  /// 사원수 키(Y축90도)       // 처음 프레임(회전값)

    Yaw = 0;
    Pitch = D3DX_PI * 90.0f / 180.0f;   /// X축 90도 회전
    Roll = 0;
 D3DXQuaternionRotationYawPitchRoll( &g_aniRot[1], Yaw, Pitch, Roll ); 

                                                  /// 사원수 키(X축90도)       // 마지막 프레임(회전값)
}

float Linear( float v0, float v1, float t )  /// 선형보간(Linear Interpolation) 함수
{
 return v0 * ( 1.0f - t ) + v1 * t;
// 다음 줄로 바꿔도 된다.
// return v0 + t * ( v1 - v0 );
}

VOID Animate()       // 보간하여 가운데 프레임들을 생성한다..
{
 static float t = 0;
 float x, y, z;
 D3DXQUATERNION quat;

 if( t > 1.0f ) t = 0.0f;

 /// 위치값의 선형보간
 x = Linear(g_aniPos[0].x, g_aniPos[1].x, t );
 y = Linear(g_aniPos[0].y, g_aniPos[1].y, t );
 z = Linear(g_aniPos[0].z, g_aniPos[1].z, t );
 D3DXMatrixTranslation( &g_matTMParent, x, y, z ); /// 이동행렬을 구한다.

// 위의 4줄은 다음의 3줄로 바꿀수 있다. //( 지난달에 했던 Lerp 함수.)
// D3DXVECTOR3 v;                             
// D3DXVec3Lerp( &v, &g_aniPos[0], &g_aniPos[1], t ); 
// D3DXMatrixTranslation( &g_matTMParent, v.x, v.y, v.z );

 D3DXQuaternionSlerp( &quat, &g_aniRot[0], &g_aniRot[1], t );   /// 회전값의 구면선형보간
 D3DXMatrixRotationQuaternion( &g_matRParent, &quat ); /// 사원수를 회전행렬값으로 변환
 t += 0.005f;

 D3DXMatrixRotationZ( &g_matRChild, GetTickCount()/500.0f );  /// 자식메시의 Z축 회전행렬
 D3DXMatrixTranslation( &g_matTMChild, 3, 3, 3 );  

                                                      /// 자식메시는 원점으로부터 (3,3,3)거리에 있음
}

렌더함수 전체부분..

VOID Render()
{
 D3DXMATRIXA16 matWorld;

    /// 후면버퍼와 Z버퍼 초기화
    g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,

                                                                          D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );

 Animate();     /// 애니메이션 행렬설정
    /// 렌더링 시작
    if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
    {
  matWorld = g_matRParent * g_matTMParent;
  DrawMesh( &matWorld );                               /// 부모 상자 그리기

  matWorld = g_matRChild * g_matTMChild * matWorld;
//  바로위의 행과 같은 결과
//  matWorld = g_matRChild * g_matTMChild * g_matRParent * g_matTMParent;
  DrawMesh( &matWorld );  /// 자식 상자 그리기

        /// 렌더링 종료
        g_pd3dDevice->EndScene();
    }

    /// 후면버퍼를 보이는 화면으로!
    g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

* 스키닝(skinning)

  피부를 붙인다. 3차원 메시는 관절과 관절 사이가 끊김 현상이 발생하기 때문에

  이를 보완하는 기법이다. 마치 사람의 뼈 위에 피부가 있어서 관절부위가 보이지 않는 것처럼..

  스키닝에는 다양한 기법들이 있다고하나.. 핵심은.. 뼈대(bone)의 애니메이션 행렬이

  메시의 정점에 얼마만큼의 가중치(weight)로 결합될 것인가 하는것이다.

  암튼. 버텍스가 본에 영향받는다.

 일반적인 스키닝 버텍스 구조체..

struct SkinedVertex

{

    D3DXVECTOR3   pos;                   // 위치.

    float                  weight[3];           // 본(bone)에 의한 가중치.

    unsigned char    BI[4];                 // 본(bone) 인덱스

    D3DXVECTOR3   Normal;               // 노말 좌표.

    D3DXVECTOR2   Tex;                    // 텍스쳐 좌표.

}

- 매트릭스 팔레트(Matrix Palette)

   기본적인 개념은 정점이 최대 4개까지 가중치를 가질 수 있는데, 이들의 가중치에 따라서

   다른 행렬을 곱해준다는 것이다. 이때 곱해주는 행렬을 최대 256개까지 매트릭스 팔레트라는

   영역에 셋팅해 놓으면 나머지는 D3D가 알아서 DrawPrimitive()함수 호출시에 처리해준다.  

   최대 256개까지 지원하는 매트릭스 팔레트에 뼈대의 애니메이션 키를 등록해 놓고 각각에

   뼈대가 영향을 미치는 정점에 가중치와 인덱스만 적절하게 셋팅되어있으면 모든것이

   DrawPrimitive() 호출 한번으로 끝나는것이다.

ex) 버텍스 구조.

ex) Vl[100] =  |  x  |   y  |  z  |  // 위치.

                    | 0.6 | 0.2 | 0.1 |  // 4번째 가중치는 1.0 - ( 0.6 + 0.2 + 0.1 )

                    | 5 | 6 | 10 | 11 |  //5번 본(bone)은 0.6의 가중치, 6번은0.2, 10번은0.1, 11번은0.1

                    | Nx  | Ny  | Nz |  // 노말

                    | Tex x  | Tex y |  // 텍스쳐

ex) 50개의 본이 매트릭스 팔레트에 셋팅되었다고 하고...

ex)  Vw[100] = Vl[100] * MP[5] * 0.6 

                       + Vl[100] * MP[6] * 0.2

                       + Vl[100] * MP[10] * 0.1

                       + Vl[100] * MP[11] * 0.1

  ※  ( Vl = 로컬  , Vw = 월드  )

* 메트릭스 팔레트의 지원.

  ATI 는 메트릭스 팔레트를 최대 37개까지 지원한다.

  nVidia 의 GeForce는 전혀 지원하지 않는다.

  그렇기 때문에 매트릭스 팔레트를 비롯한 모든 스키닝 기법은 GPU 프로그래밍을 통해

  직접 구현한다.

* 버텍스 쉐이더는 CPU에서도 가능하지만 GPU에서 하면 더 나은 속도향상을 가져온다.

  장치 생성시 MIXED 설정으로 한다.

* 픽셀 쉐이더는 GPU에서만 지원된다.

* 책의 예제소스를 보면..

- Init 부분의 코드조각..

/// 컬링기능을 끈다.
    g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

    /// Z버퍼기능을 켠다.
    g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );

    /// 정점에 색깔값이 있으므로, 광원기능을 끈다.
    g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

 /// matrix palette 사용
    g_pd3dDevice->SetRenderState( D3DRS_INDEXEDVERTEXBLENDENABLE, TRUE );

 /// blend weight는 4개(오타 아님! 4개!)
    g_pd3dDevice->SetRenderState( D3DRS_VERTEXBLEND, D3DVBF_3WEIGHTS );

- 버텍스 초기화 부분...

HRESULT InitVB()
{
    /// 정점버퍼 생성
    if( FAILED( g_pd3dDevice->CreateVertexBuffer( 50*2*sizeof(CUSTOMVERTEX),
                                                  0, D3DFVF_CUSTOMVERTEX,
                                                  D3DPOOL_DEFAULT, &g_pVB, NULL ) ) )
    {
        return E_FAIL;
    }

    CUSTOMVERTEX* pVertices;
    if( FAILED( g_pVB->Lock( 0, 0, (void**)&pVertices, 0 ) ) )
        return E_FAIL;
    for( DWORD i=0; i<50; i++ )
    {
        FLOAT theta = (2*D3DX_PI*i)/(50-1);

        pVertices[2*i+0].position = D3DXVECTOR3( sinf(theta),-1.0f, cosf(theta) );
        pVertices[2*i+0].b[0]  = 1.0f;
        pVertices[2*i+0].b[1]  = 0.0f;
        pVertices[2*i+0].b[2]  = 0.0f;
        pVertices[2*i+0].index  = 0x0000;   /// 0번 가중치는 0번 행렬의 영향을 1.0만큼 받음
        pVertices[2*i+0].color  = 0xffffffff;
        pVertices[2*i+0].tu       = ((FLOAT)i)/(50-1);
        pVertices[2*i+0].tv       = 1.0f;

        pVertices[2*i+1].position = D3DXVECTOR3( sinf(theta), 1.0f, cosf(theta) );
        pVertices[2*i+1].b[0]  = 0.5f;
        pVertices[2*i+1].b[1]  = 0.5f;
        pVertices[2*i+1].b[2]  = 0.0f;
        pVertices[2*i+1].index  = 0x0001;   /// 0번 가중치는 1번 행렬의 영향을 0.5만큼 받음
        pVertices[2*i+1].color    = 0xff808080;   
        pVertices[2*i+1].tu       = ((FLOAT)i)/(50-1);
        pVertices[2*i+1].tv       = 0.0f;
    }
    g_pVB->Unlock();

    return S_OK;
}

VOID Animate()
{
 /// 0번 행렬은 단위행렬
 D3DXMatrixIdentity( &g_mat0 );

 /// 0 ~ 2PI 까지(0~360도) 값을 변화시킴 Fixed Point기법 사용
 DWORD d = GetTickCount() % ( (int)((D3DX_PI*2) * 1000) );
 /// Y축 회전행렬
    D3DXMatrixRotationY( &g_mat1, d / 1000.0f );
}

렌더함수 전체..

VOID Render()
{
 D3DXMATRIXA16 matWorld;

    /// 후면버퍼와 Z버퍼 초기화
    g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,

                                                                     D3DCOLOR_XRGB(255,255,255), 1.0f, 0 );

 /// 애니메이션 행렬설정
 Animate();
    /// 렌더링 시작
    if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
    {

  /// 0번 매트릭스 팔레트에 단위행렬
  g_pd3dDevice->SetTransform( D3DTS_WORLDMATRIX(0), &g_mat0 );
  /// 1번 매트릭스 팔레트에 회전행렬
  g_pd3dDevice->SetTransform( D3DTS_WORLDMATRIX(1), &g_mat1 );
        g_pd3dDevice->SetTexture( 0, g_pTexture );
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );

  DrawMesh();

        /// 렌더링 종료
        g_pd3dDevice->EndScene();
    }

    /// 후면버퍼를 보이는 화면으로!
    g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

<< 파일 설명 >>

08.KeyFrameAni.zip        :     키프레임 애니메이션 예제소스 (책)

09.Skinning.zip              :     스키닝 예제소스(책)

pdevice->setrenderstate(알파블렌드, true);

m_pEffect->SetTechnique( m_hTechnique );

m_pEffect->Begin( NULL, 0 );
m_pEffect->BeginPass( 0 );


m_pEffect->SetTexture(tex, ptex); ///color텍스쳐
m_pEffect->SetTexture(alphatex,pAtex);/// 알파텍스쳐 1              -------------  1

m_pEffect->CommitChanges();                                                 --------------- 3

pDevice->renderprimitive(...); ///프리미티브 호출

m_pEffect->SetTexture(alphatex,pAtex_2);  // 알파텍스쳐2           -------------- 2

m_pEffect->endpass();
m_pEffect->end();

pdevice->setrenderstate(알파블렌드, false);

*  위에서  1 번에서 알파텍스쳐를 set한후에 프리미티브를 호출하는데  이때   3번을 안해주면

  2번의 알파텍스쳐가 적용된다.

   BeginPass()와 EndPass() 사이에서 스테이트가 바뀌면 이펙트에 바로 적용되지 않고
CommitChanges()를 불러줘야  제대로 된다. 

present 하나로 플립하기 때문에 풀스크린시 다이얼로그 띄우기가 가능하지 않았다.

그래서 존재하는것이..

IDirect3DDevice9::SetDialogBoxMode 라는 메소드.

바로 쓰면 되는것이 아니고. 쓰기전 약간의 세팅이 필요하다.

////////////////////////////////////////////////////////////////////////////////////

자료 출처 : 뽈따구님 홈피
작 성 자 : 뽈따구님

D3D디바이스를 생성할때
D3DPRESENT_PARAMETERS 인자중에 몇가지를 셋팅.
[1] SwapEffect = D3DSWAPEFFECT_DISCARD;
[2] BackBufferFormat = D3DFMT_X8R8G8B8; 또는 D3DFMT_X1R5G5B5, D3DFMT_R5G6B5
[3] Flags        |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;

위에 옵션을 셋팅해서 디바이스를 생성한후에
D3DDevice->SetDialogBoxMode( TRUE );