반응형

typedef struct _VERTEX_POSCOLOR
{

D3DXVECTOR3 pos;

DWORD color;
 static const DWORD FVF_POS_DIFFUSE;  //==D3DFVF_POS_DIFFUSE
public :
 //생성자로 인수받아 초기화 해준다
}VERTEX_POSCOLOR;


 

 

VERTEX_POSCOLOR g_Vertices[3];

 

g_Vertices[0]=VERTEX_POSCOLOR(-10.0f,-10.0f, 0.0f, 0xffffffff);
  g_Vertices[1]=VERTEX_POSCOLOR(10.0f,-10.0f, 0.0f, 0xffffffff);
  g_Vertices[2]=VERTEX_POSCOLOR( -5.0f, 10.0f, 0.0f, 0xffffffff);

 

 

 

 

 

_pD3dDevice->SetFVF( VERTEX_POSCOLOR::FVF_POS_DIFFUSE );
 _pD3dDevice->DrawPrimitiveUP( D3DPT_POINTLIST,3, (void *)g_Vertices, sizeof(VERTEX_POSCOLOR) );

반응형
반응형

http://ergate.tistory.com/117

 

 



Directx 에서 지원하는 Sphere함수를 구현해보았습니다.

Slices는 나누어질 삼각형의 갯수 이며 Stack은 사진에서 Y축으로 나누어질 갯수 입니다.

Radius는 반지름의 값이며 Slices Stack Radius 의 값을 조정하시면 그 값에 맞게 Sphere가 그려집니다.

그리는 방식은 Vertices로 각 위치의 Point를 찍어주며 이것을 index buffer르 사용하여 사과의 껍질을 벗겨내는 형식으로 

각포인트를 이어서 삼각형을 만들어 주시면 됩니다.




 

#include <Windows.h>
#include <mmsystem.h>
#include <d3dx9.h>

//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
LPDIRECT3D9             g_pD3D = NULL; 
LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; 
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL;
LPD3DXMESH                  g_pMesh   = NULL; 
LPDIRECT3DINDEXBUFFER9      g_pIndexVB = NULL;

struct CUSTOMVERTEX
{
 FLOAT x, y, z;     
 DWORD color;       
};

#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)


struct INDEX
{
 WORD _0, _1, _2;
};

int Slices = 6;
int Stack = 4;
int numvertex = (Slices+1)*2+((Stack-3)*Slices);
int numface = (Slices*2)+((Stack-2)*2)*Slices;

 


//-----------------------------------------------------------------------------
// Name: InitD3D()
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
 if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
  return E_FAIL;

 D3DPRESENT_PARAMETERS d3dpp;
 ZeroMemory( &d3dpp, sizeof( d3dpp ) );
 d3dpp.Windowed = TRUE;
 d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
 d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

 if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
  D3DCREATE_SOFTWARE_VERTEXPROCESSING,
  &d3dpp, &g_pd3dDevice ) ) )
 {
  return E_FAIL;
 }

 g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

 g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME  );

 g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

 return S_OK;
}

 

//-----------------------------------------------------------------------------
// Name: InitGeometry()
//-----------------------------------------------------------------------------
HRESULT InitGeometry()
{

 D3DXCreateSphere( g_pd3dDevice, 2.0f, 5, 4, &g_pMesh, NULL );  

 float Radius = 2.0f;

 CUSTOMVERTEX *g_Vertices = new CUSTOMVERTEX[numvertex];


 g_Vertices[0].x = 0.0f;
 g_Vertices[0].y = Radius; 
 g_Vertices[0].z = 0.0f;
 g_Vertices[0].color = 0xffffffff;

 for( int i=0+1, k=1; i<Stack; ++i )
 {
  D3DXVECTOR3 tmp( 0.0f, Radius * cosf( ( D3DX_PI / Stack ) * i ), Radius * sinf( ( D3DX_PI / Stack ) * i ));
  for( int j=0; j<Slices; ++j, ++k )
  {
   float temp = Radius - ( Radius - tmp.z );
   g_Vertices[k].x = temp * cosf(D3DXToRadian( (360/Slices) * j ));
   g_Vertices[k].y = tmp.y;
   g_Vertices[k].z = temp * sinf(D3DXToRadian( (360/Slices) * j ));
   g_Vertices[k].color = 0xffffffff;
  }
 }


 g_Vertices[numvertex-1].x = 0.0f;
 g_Vertices[numvertex-1].y = -Radius;     
 g_Vertices[numvertex-1].z = 0.0;
 g_Vertices[numvertex-1].color = 0xffffffff;


 if( FAILED( g_pd3dDevice->CreateVertexBuffer( numvertex * sizeof( CUSTOMVERTEX ),
  0, D3DFVF_CUSTOMVERTEX,
  D3DPOOL_DEFAULT, &g_pVB, NULL ) ) )
 {
  return E_FAIL;
 }

 VOID* pVertices;
 if( FAILED( g_pVB->Lock( 0, sizeof( g_Vertices ), ( void** )&pVertices, 0 ) ) )
  return E_FAIL;
 memcpy( pVertices, g_Vertices, sizeof( CUSTOMVERTEX ) * numvertex);
 g_pVB->Unlock();


 int j=0;
 int z=0;

 INDEX *index = new INDEX[numface];

 for(z=0; z<Slices; ++z)
 {   
  index[z]._0 = 0;
  index[z]._1 = z+1;
  index[z]._2 = z+2-j;
  if( z == Slices - 2 )
  {
   j = Slices;
  }
 }

 int t = z;
 int tmp = 0;
 int tmp2 = 0;
 int a = 0;


 for( int i=0; i<Stack - 2; ++i )
 {
  tmp = (Slices + 1) + ( i * Slices );
  tmp2 = 2 + ( i * Slices ); 
  for( int j=0; j<Slices; ++j )
  {
   if( j == (Slices - 1) )
   {
    a = Slices;
   }
   index[t]._0 = tmp2 + j - a;         
   index[t]._1 = tmp2 + j - 1;         
   index[t]._2 = tmp2 + j + Slices - a;       

   index[t+1]._0 = tmp + j + 1 - a;                
   index[t+1]._1 = tmp + j - ( Slices );   
   index[t+1]._2 = tmp + j;    
   t+=2;
  }
  a = 0;
 }

 int b;

 b = t;

 int q = 0;
 for( int i=0; i<Slices; ++i )
 {
  index[b]._0 = tmp + i;
  index[b]._1 = tmp + Slices;
  index[b]._2 = tmp + i + 1 - q;
  if( i  == Slices - 2 )
  {
   q = Slices - i;
  }
  b++;
 }

 

 if( FAILED( g_pd3dDevice->CreateIndexBuffer( numface * sizeof(INDEX), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &g_pIndexVB, NULL ) ) )
 {
  return E_FAIL;
 }

 VOID* pIndices;
 if( FAILED( g_pIndexVB->Lock( 0, sizeof(INDEX)*numface, (void**)&pIndices, 0 ) ) )
  return E_FAIL;
 memcpy( pIndices, index, sizeof(INDEX)*numface );
 g_pIndexVB->Unlock();


 return S_OK;
}


//-----------------------------------------------------------------------------
// Name: Cleanup()
//-----------------------------------------------------------------------------
VOID Cleanup()
{


 if( g_pIndexVB != NULL )
  g_pIndexVB->Release();

 if( g_pMesh != NULL )
  g_pMesh->Release();

 if( g_pVB != NULL )
  g_pVB->Release();

 if( g_pd3dDevice != NULL )
  g_pd3dDevice->Release();

 if( g_pD3D != NULL )
  g_pD3D->Release();
}

 

//-----------------------------------------------------------------------------
// Name: SetupMatrices()
//-----------------------------------------------------------------------------
VOID SetupMatrices()
{
 D3DXMATRIXA16 matWorld;


 UINT iTime = timeGetTime() % 9000;
 FLOAT fAngle = iTime * ( 2.0f * D3DX_PI ) / 9000.0f;
 D3DXMatrixRotationY( &matWorld, fAngle );
 g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );


 D3DXVECTOR3 vEyePt( 0.0f, 0.0f,-10.0f );
 D3DXVECTOR3 vLookatPt( 0.0f, 0.0f, 0.0f );
 D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f );

 D3DXMATRIXA16 matView;
 D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
 g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );


 D3DXMATRIXA16 matProj;
 D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI / 4, 1.0f, 1.0f, 100.0f );
 g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
}

 

//-----------------------------------------------------------------------------
// Name: Render()
//-----------------------------------------------------------------------------
VOID Render()
{
 g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 0, 0, 0 ), 1.0f, 0 );

 if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
 {
  SetupMatrices();

 

  g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof( CUSTOMVERTEX ) );
  g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
  g_pd3dDevice->SetIndices( g_pIndexVB );

  //  g_pd3dDevice->DrawPrimitive( D3DPT_POINTLIST, 0, numvertex );

  g_pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST, 0, 0, numvertex, 0, numface );


  g_pd3dDevice->EndScene();
 }

 g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

 


//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: The window's message handler
//-----------------------------------------------------------------------------
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
 switch( msg )
 {
 case WM_DESTROY:
  Cleanup();
  PostQuitMessage( 0 );
  return 0;
 }

 return DefWindowProc( hWnd, msg, wParam, lParam );
}

 


//-----------------------------------------------------------------------------
// Name: WinMain()
//-----------------------------------------------------------------------------
INT WINAPI wWinMain( HINSTANCE hInst, HINSTANCE, LPWSTR, INT )
{
 UNREFERENCED_PARAMETER( hInst );

 WNDCLASSEX wc =
 {
  sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,
  GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
  L"D3D Tutorial", NULL
 };
 RegisterClassEx( &wc );

 HWND hWnd = CreateWindow( L"D3D Tutorial", L"D3D Tutorial 03: Matrices",
  WS_OVERLAPPEDWINDOW, 100, 100, 800, 600,
  NULL, NULL, wc.hInstance, NULL );

 if( SUCCEEDED( InitD3D( hWnd ) ) )
 {
  if( SUCCEEDED( InitGeometry() ) )
  {
   ShowWindow( hWnd, SW_SHOWDEFAULT );
   UpdateWindow( hWnd );

   MSG msg;
   ZeroMemory( &msg, sizeof( msg ) );
   while( msg.message != WM_QUIT )
   {
    if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
    {
     TranslateMessage( &msg );
     DispatchMessage( &msg );
    }
    else
     Render();
   }
  }
 }

 UnregisterClass( L"D3D Tutorial", wc.hInstance );
 return 0;
}

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

점 그리기 -크기 변환  (0) 2012.11.02
점그리기  (0) 2012.11.02
디바이스를 잃었을때의 복구 절차  (0) 2012.11.02
그래픽카드 디바이스. D3D_Device  (0) 2012.11.02
Directx3D 에서 2D 점 그리기  (0) 2012.11.02
반응형

 
Lost Device
① 원리
-> Full Screen Mode에서 ALT+TAB을 눌러 Task를 전환하면,
 윈도우는 자동적으로 응용 프로그램에 대한 전환 처리를 시행.
 이때 다시 ALT+TAB을 눌러 원래의 3D 어플리케이션 복구하려면 오류가 발생된다.
 이 원인은 3D 카드의 설정이 최초  ALT+TAB시 비 Direct3D 응용 프로그램을 위해 설정 변화가 일어났기 때문

② 대책
-> 어플리케이션에서 현재 그래픽 카드의 상태를 확인하고 있다가, 복구시점에서 Device를 Reset하면 된다

③ 복구검사

IDirect3DDevice::TestCooperativeLevel()을 호출하여, 디바이스를 복구 할 수 있는지 검사
-> 반환값(HRESULT)이 D3DERR_DEVICELOST인 경우 디바이스가 소실되었고 아직 복구할 수 없는 상태.
    복구할 수 있을 때 까지 대기한다. 
-> D3DERR_DEVICENOTRESET인 경우 디바이스가 소실되지만 지금 복구할 수 있는 상태이다. 디바이스를 복구한다.


④ 복구절차

-> D3DPOOL_DEFAULT로 잡은 리소스들을 전부 릴리즈한다.
    (안그러면 다음에 호출될 IDirect3DDevice::Reset()이 실패할것이다) 
-> IDirect3DDevice::Reset()을 호출한다.
    (Reset()을 그냥 IDirect3DDevice의 복구 명령어라 생각하면 이해가 편함) 
-> 디바이스를 다시 셋팅한다.
    (랜더스테이트, 뷰 행렬 등..)
-> D3DPOOL_DEFAULT로 잡은 리소스들을 다시 로드한다. 

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

점그리기  (0) 2012.11.02
Directx D3DXCreateSphere 구현  (0) 2012.11.02
그래픽카드 디바이스. D3D_Device  (0) 2012.11.02
Directx3D 에서 2D 점 그리기  (0) 2012.11.02
SetScissorRect 영역 그리기  (0) 2012.11.02
반응형

http://cafe.naver.com/mingameworld/1745

 

 

우리가 만약 API로만 프로그래밍을 한다면, 3D는 구현도 어려울 뿐더러, 우리의 게임은 CPU에만 의존하여, 연산을 할것이고,

 

정작 게임을 하기위해 달아놓은(혹은 그렇지 않을수도있지만) 그래픽카드는 편하게 놀게 두는 프로그램이 될것입니다.

 

그래픽연산에는 분명히 CPU보다도 그래픽카드가 더욱 우월함에도 불구하고 말이죠.

 

정확하게 Direct3D만 사용한다고해서, 그래픽카드 GPU의 모든 능력을 사용하는것은 아니지만,

 

최소한 화면에 우리의 게임화면을 그려주는 역할은 그래픽카드에게 맞기는 편이 게임의 보편적 구동성능향상에 도움이 될것입니다.

 

이를위해 우리는 하드웨어인 그래픽카드를 우리가 직접 조작하여야만하며, 하드웨어의 직접적인 조종은 어셈블리언어를 해야만 가능한 일입니다.

 

하지만 MicroSoft사는 개발자의 편의를 위해 DirectX를 만들며, 손쉬운 자체 함수만으로 그래픽카드를 조종할수 있는 함수를 개발해 두었습니다.

 

D3D_SDK를 컴파일러에 포함시킬줄 안다는 전제하에, 사용방법을 간략하게만 설명하겠습니다.(책에 오히려 더 자세히 설명이 되어있으므로,)

 

LPDIRECT3D9 m_pD3D;   //D3D

D3DCAPS9    caps;

m_pD3D = Direct3DCreate9(D3D_SDK_VERSION); //D3D_SDK_VERSION = 현재 사용할 DirectX SDK의 버전을 읽어오는 매크로

 

여기까지 오면 m_pD3D에는 우리의 프로그램에서 D3D를 사용하기 위한 기본적인 초기화가 모두 이루어집니다.

 

m_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);

 

여기서 HAL이란,

다양한 종류의 그래픽카드 장치들이 현재 크게 칩셋 제조사로 Nvidia와 Radeon이 있고, 여기서 기계적 레퍼런스를 개조하거나, 또는 다양한

옵션을 덧붙여, 다양한 유통사(기가바이트,아수스,이엠텍, 사파이어 등등)에서 그래픽카드를 내놓습니다.

이들은 모두 기계어로 프로그래밍 되어있으며, 똑같은 기능도 각자의 방법으로 프로그래밍 되어있을것입니다.

이해를 돕기 위한 쉬운예로, 똑같이 화면에 하나의 점을 찍어내는 함수 조차도, 어떤회사는 SetPixel();이라고 지을수 있고, 다른회사는

DrawPixel();이라고 지었을수 있습니다.

이러한 각자 개성이 강하게 프로그래밍 된 소스는 구동시에 어떤 그래픽카드는 게임이 정상적으로 구동되고, 어떤 그래픽카드는 정상적으로

구동되지 않는 문제를 충분히 발생시킬수 있으며, 치명적인 에러를 유발시킬 위험요소가 존재합니다. 따라서 이에 대한 표준(프로토콜/규약)

으로써, 제공할 기능에 대한 표준규약을 MicroSoft에서 제공함으로써, 제조사들은 이 규약만 지켜서 하드웨어를 개발하게 되면,

각 개발사가 그래픽카드를 어떤식으로든 내부 내용을 수정하더라도 DirectX에서는 해당 그래픽카드가 문제없이 구동하게 될수 있게 됩니다.

이 규약이 바로 HAL입니다.

 

따라서 이 함수는 현재 이 프로그램이 구동되고 있는 하드웨어(그래픽카드)의 구성(또는 옵션)정보를 읽어와서, caps라는 구조체 안에

넣어주게됩니다.

그리고, 그 전달받은 값에 대하여 체킹을 합니다.

"버텍스 연산을 사용하는데 있어, 현재 그래픽카드가 지원을 하는지에 대하여"

 if(caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
 {
  nVP = D3DCREATE_HARDWARE_VERTEXPROCESSING;
 }
 else
 {
  nVP = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
 }
 

만약 지원을 하지않는다면, 소프트웨어적으로 지원을 하지만, 아마 부두급 그래픽카드를 사용하지 않는한 이것은 지원 할것입니다.

 

그리고나선 내가 이제 현재 이 그래픽카드에 대하여, 내가 어떤식으로 사용할지 옵션을 채워넣습니다.

이 인자값은 상당히 많으므로, 함수로써 전달하기에 무리가 있어, 구조체에 모든 데이터를 넣고, 그 구조체 하나를 함수를 통해 넘겨주는

형식으로 옵션을 적용시킵니다. 

 D3DPRESENT_PARAMETERS  d3dpp;
 memset(&d3dpp, 0, sizeof(D3DPRESENT_PARAMETERS));   //선언된 구조체에 대하여 초기화 = zeromemory

 d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;   //더블버퍼링(백버퍼)간의 화면 전환을 어떻게 할것인가?
 d3dpp.Windowed  = true;                               //풀스크린시 펄스를 두기도함, 하지만 무조건 트루
 d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;   //임시로 저장시켜두는 벡버퍼의 구성 포멧 지정, 항상 이렇게..
 d3dpp.EnableAutoDepthStencil = true;              //깊이 버퍼(Z버퍼)의 사용을 할것인가?
 d3dpp.AutoDepthStencilFormat = D3DFMT_D16;   //깊이의 단계를 어느정도로 세분화할것인가? D16은 16비트로

                                                                 // 대략 약65000가지의 깊이의 경우를 표현할수 있습니다.

                                                                 // 이정도면 항상 충분하므로, D32도 존재하지만 D16정도로 해줍시다.

 

옵션을 모두 지정하였다면, 지정된 대로 그래픽카드 인터페이스 생성한뒤, 앞으로 내가 명령을 내릴 그래픽카드를 부를 이름을 붙여줍니다. 

m_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, g_hWnd, 
  nVP, &d3dpp, &m_pd3dDevice)

이렇게하여 성공적으로 그래픽인터페이스가 생성하고 pd3dDevice라고 이름을 붙여줬다면, 

우리는 앞으로 m_pd3dDevice를 통해 그래픽카드에게 명령을 내릴수 있게됩니다.

 

이것이 그래픽카드 인터페이스를 생성하는 전부입니다.

그리고, 이 m_pd3dDevice라는 녀석에게 5장에서 설명한 파이프라인에 해당하는 내용들을 모두 적용시켜줘야만,

우리는 우리가 원하는 화면을 얻어낼수 있을것입니다.

 

여기서 사족을 덫붙여 한가지 팁을 드린다면,

이 그래픽카드 인터페이스 디바이스는 내 프로그램 내에 하나만 존재하면 된다는 것입니다.

그래픽카드가 두개를 각자 사용하여, 게임을 구동시켜야 할 이유도 없을 뿐더러,

(크로스파이어같은 기술은 2개의 그래픽카드를 하나의 그래픽카드로 인식시켜 연산을 나누는 행위이므로 해당하지 않음)

하나뿐인 그래픽카드의 셋팅을 여러번 받아올 필요가 없다는 것이죠.

우리는 이미 "프로그램 구동중 어떠한 경우에도 한개만 필요한 개체를 다루는 방법"에 대해서 알고 있습니다.

바로 싱글턴이죠.

이 디바이스 셋팅 작업을 클래스화 시켜, 싱글턴 구조로 구성해 놓으면, 앞으로 DirectX게임 개발에 있어 훨~씬 수월해 질수있습니다.

화면을 그릴 모든 것들은 m_pd3dDevice 이녀석을 통해서 모두 이루어 지기 때문에 자주 이녀석을 불러야 하거든요.

기본적으로 싱글턴 패턴을 구성하실수 있다는 가정하에 매크로로 아래와 같이 선언해 놓으시면 훨~씬 더 좋습니다.

예시) //자신의 함수,변수명에 따라 달라질수 있으므로 적절히 수정하여 사용하셔야합니다.

#define D3D_DEVICE CD3DDevice::GetInstance()->m_pD3dDevice 

 

이를 통해, 이 클래스의 헤더가 인클루드가 되어있는 어디서든

D3D_DEVICE-> 이렇게하시면,

CD3DDevice::GetInstance()->m_pD3dDevice 클래스 외부에서도 이것과 동일해지므로,

외부에서도 손쉽게 D3D_DEVICE-> 요렇게 손쉽고, 보기도 편한 소스가 만들어 집니다.

반응형
반응형



http://blog.naver.com/kimachine/130104998068

지금도 주말마다 개발하고 있는 게임이 있는데 쉐이더 공부를 하면서 하니까 오래 걸린다.

그림이 점점 좋아 지고는 있으나 직업으로 하지 못하니 시간을 내기 힘들고 주말에만 잠깐씩 할 수 있다.

공부해서 알게된 쉐이더 기법을 하나씩 적용해 나갔다.

 

1. HDR Lighting 기법

노말매핑을 적용한 물체에 HDR(High Dynamic Range) Lighting 을 적용했다. 

반사되는 부분이 빛이 옆으로 번지는 기법 (Blooming)이 사용되었다.

HDR을 하기 위해서는 먼저 16비트 렌더링 타겟에 물체를 렌더링한다.  즉, A16R16G16B16 포멧을 갖는 텍스쳐를 만들어 이것을 렌더 타겟으로 설정한다.  이후 쏘이는 빛의 세기를 1.0을 초과하는 큰 값을 가지게 하여 렌더링한다.  그러면 각 물체의 표면이 어두운 곳은 변함이 없지만 밝은 곳은 1.0을 넘는 밝기를 가지게 된다.  16비트 텍스쳐는 각 픽셀의 밝기값을 훨씬 크게 저장할 수 있다.  하지만 마지막 보여지는 화면은 각 픽셀의 밝기가 1.0까지만 되므로 1.0을 초과하는 밝기를 다른 형태로 표현해 줘야 한다.  그러기 위해 Blooming효과를 준다.  Blooming 효과 말고도 tone mapping이나 다른 방식이 있으나 번쩍이는 효과를 주기로 했다.  이렇게 얻어진 16비트 텍스쳐는 필터링을 거쳐서 밝은 부분만 걸러내는 작업을 통과하게 된다.  그러면 어두운 화면에 밝은 부분이 군데 군데 남게 된다.  이렇게 얻어진 화면을 Gaussian Blur를 한다.  Blur는 번지게 하는 기법을 말하는데 간단히 말하면 주위 근처의 픽셀 밝기값들을 현재의 픽셀값에 더한후 나누어 주는 것을 말한다.  그러면 어두운 화면에 번져있는 부분이 있는 텍스쳐가 얻어지는데 이것을 원래 그림과 합해서 렌더링해주면 된다.

 





 


2. Environment Mapping

  환경매핑(Environment Mapping)은 일반적으로 매끈한 금속성 표면에 주위가 비춰지는 효과를 나타내 주는 기법을 말하나 나는 바다의 반짝이는 효과를 주기 위해 사용되었다.  바다는 전에 골프장에서 썼던 반사맵을 이용해서 그리면 바다 처럼 보이지가 않았다.  그래서 반짝거리는 효과가 주로 나타내는 데 집중했다.  일반적으로 물을 그릴때는 물의 표면의 움직임(파도)을 나타내는 normal map(법선맵)을 가지고 environment map(환경맵)의 좌표값을 알아낸후 텍스쳐로 사용한다.

  일반적인 노말매핑은 노말맵에 들어 있는 값 (예, -0.7, 0.0, 0.7)을 물체에서 그 좌표에 해당하는 표면이 바라보는 방향으로 간주한다.  즉 어떤 물체의 표면에 매핑된 노말맵의 좌표값이 (0.1, 0.2) 라면 이 좌표값에 있는 노말맵의 색깔 (RGB) 값을 3차원 벡터로 바꿔주고 그 벡터가 가리키는 방향이 그 표면이 보고 있는 방향이라고 간주하는 것이다.  만약 그 표면이 광원을 향하고 있으면 밝게 그려주고 그렇지 않으면 어둡게 그려주므로써 표면을 픽셀단위로 굴곡을 줄 수 있다.  이것은 결국 로우폴리곤 모델로 하이폴리곤 모델을 나타내 주는 방법이다.  그러나 환경매핑은 같은 노말값을 이용해서 광원에 따라 밝기를 계산하는게 아니고 그 노말값이 가리키는 방향에 있는 환경 (즉, 주변물체)의 표면을 그려준다.  하늘을 예로 들면 노말값이 수직이면 하늘의 정 중앙의 이미지를 텍스쳐링하는 식이다.  그러면 결국 울퉁불퉁한 표면이 주위의 환경을 반사하는 물체가 그려진다.  이때 반사되는 물체들을 일일히 찾아서 그려주는 것이 아니고 환경맵이라는 주변을 찍은 텍스쳐를 이용해서 그려준다.  이때 사용하는 텍스쳐는 큐브맵(Cube map) 인데 박스형태의 이미지로 6개의 면으로 되어 있다.  즉, 상하, 좌우, 앞뒤를 가운데 에서 찍은 이미지로 사방의 환경을 나타낸 것이다. 

  물은 이 방법에서 나아가 표면의 노말값이 시간에 따라 바뀌도록 (즉, 돌려주거나 움직이거나 등) 해야 한다.  그러면 겉에 반사된 이미지가 물결에 따라 출렁거리게 보인다.  아래의 스크린 샷에서 반짝이는 하얀 점들은 환경맵에 있는 광원이 번진 것이다.  광원을 크게 그리면 너무 밝게 보여서 멀리 있는 물처럼 보이지를 않아서 작은 광원이 모여있는 방식으로 그렸다.


[출처] 쉐이더 기법 1|작성자 바람소리


반응형

'그래픽스(Graphics) > Shader' 카테고리의 다른 글

[소스] 해칭(Hatching) HLSL 소스  (0) 2013.01.05
VS에서 HLSL 편집하기 InteliShade  (0) 2013.01.05
셰이더 내장함수  (0) 2012.11.02
smoothstep  (0) 2012.11.02
NVIDIA계열 그래픽카드 오버클럭 하기  (0) 2012.10.31
반응형

#define  FVF_VERTEX_LINE_2D ( D3DFVF_XYZRHW | D3DFVF_DIFFUSE )

struct VERTEX_LINE_2D 
{
  D3DXVECTOR4 vRHW; 
  D3DCOLOR Color; 
}; 


void CMapEditView::DXG_DrawDot( int x,int y, DWORD color )
{

VERTEX_LINE_2D v;
v.vRHW.x=x;
v.vRHW.y=y;
v.vRHW.z=1;
v.vRHW.w=1;
v.Color=color;
m_pd3dDeviceBack->SetFVF(FVF_VERTEX_LINE_2D);
m_pd3dDeviceBack->DrawPrimitiveUP(D3DPT_POINTLIST, 1, &v, sizeof(VERTEX_LINE_2D));


}

반응형
반응형

http://blog.naver.com/inushaha?Redirect=Log&logNo=10020452097

 

내장 함수 설명
abs(x) 절대값을 구한다(x의 각 성분에 대해).
acos(x)
x의 모든 성분의 아크코사인 값을 구한다.
각 성분들의 값은 [ 1, 1] 사이에 있어야 한다.
all(x) x의 모든 성분들이 0이 아닌지를 테스트한다.
any(x) x의 성분 중 0이 아닌 것이 있는지 테스트한다.
as in(x)
x의 각 성분의 아크사인 값을 구한다.
각 성분들의 값은 [ p/2, p/2] 이내에 있어야 한다.
atan(x)
x의 아크탄젠트 값을 구한다.
반환되는 값은 [ p/2, p/2]의 범위 안에 있다.
atan2(y, x)
y/x의 아크탄젠트 값을 구한다. y와 x의 부호는 [-p, p] 범위 안에 있는
반환 값들의 사분면을 결정하는 데 쓰인다. atan2는 원점을 제외한 모든
다른 점들에 대해서도 잘 정의되어 있는데, 심지어 x가 0이고 y가 0이
아닌 상황에서도 잘 동작한다.
ceil(x) x보다 크거나 같은 정수 값을 반환한다.
clamp(x, min, max) [min, max] 범위를 벗어나지 않게 값을 자른다.
Clip(x)
x의 어떤 성분이라도 0부다 작으면 현재 픽셀 값을 버린다. 이것을
이용하여 x의 각 원소가 평면으로부터의 거리를 나타내게 하면 평면
클립도 구현할 수가 있다. 이것은 texkill 같은 명령어를 만들고자 할 때
사용할 수 있는 내장 함수이다.
cos(x) x의 코사인을 구한다.
cosh(x) x의 하이퍼볼릭 코사인(hyperbolic cos ine)을 구한다.
cross(a , b) a , b 벡터의 외적을 구한다.
D3DCOLORtoUBYTE4(x)
4D 벡터 형태인 x의 각 성분을 몇몇 하드웨어에서 지원하는 UBYTE4
스트림 형태로 바꾼다.
ddx(x) 스크린 공간 기준인 x 좌표의 편 미분계수를 구한다.
ddy(x) 스크린 공간 기준인 y 좌표의 편 미분계수를 구한다.
degrees(x) 라디안 값을 각도 값(0∼360도 사이)으로 바꾼다.
determinant(m) m행렬의 행렬식을 구한다.
distance(a , b) a , b 사이의 거리를 구한다.
dot(a , b) a , b 벡터의 내적을 구한다.
exp(x) e의 x 제곱 값을 구한다.
exp2(a) 2의 x 제곱 값이다(각 원소마다).
faceforward(n, i, ng) n * s ign(dot(i, ng)) 값을 구한다.
floor(x) x보다 같거나 작은 것 중 가장 큰 정수 값을 구한다.

fmod(a , b)
a/b의 부동 소수점형(실수형) 나머지를 구한다. a = i * b + f에서 I는
정수형이고, f는 x와 같은 부호를 가지고 있고, f의 절대값은 b보다는 작다.
frac(x) X의 소숫점 부분을 구한다
frexp(x, out exp)
x의 가수와 지수를 계산한다. frexp는 exp의 결과 매개변수에 저장된
가수와 지수를 계산한다. 만일 x가 0일 때는 가수와 지수의 계산 결과를
0으로 계산한다.
fwidth(x) abs(ddx(x))+abs(ddy(x))를 반환한다.
isfinite(x) x가 유한이면 true, 그렇지 않으면 false를 반환한다.
is inf(x) x가 +INF이거나 INF이면 true를, 그렇지 않으면 false를 반환한다.
isnan(x)
x가 NAN이거나 QNAN이면 true를, 그렇지 않으면 false를 반환한다.
CNAN:Net a numbor-잘못된 실수 값
ldexp(x, exp) * 2ex p 값을 구한다.
len(v) 벡터 길이
length(v) 벡터 v의 길이를 구한다.
lerp(a , b, s)
s가 0이면 a를, 1이면 b를 반환하는 a와 b의 선형 보간 값인 a + s(b
a)의 결과 값을 계산한다.
log(x)
지수가 e 인 x의 로그 값을 구한다. x가 음수면 indefinite 값을 반환한다.
x가 0이면 +INF를 반환한다.
log10(x)
지수가 10인 X의 로그 값을 구한다. x가 음수이면 indefinite를, 0이면
+INF를 돌려준다.
log2(x)
지수가 2인 x의 로그 값을 구한다. x가 음수이면 indefinite를, 0이면
+INF를 돌려준다.
max(a, b) a와 b 중 큰 것을 선택한다.
min(a, b) a와 b 중 작은 것을 선택한다.
modf(x, out ip)
x 값을 x와 같은 부호를 같은 소수부와 정수부로 나눈다. 부호가 있는
소수 부분은 반환되고, 정수부는 out ip 값에 저장된다.
mul(a, b)
a와 b의 행렬 곱셈 연산을 수행한다. a가 벡터이면 행 벡터로 인식된다.
b가 벡터면 열 벡터로 인식된다. a의 열과 b의 행은 반드시 같아야 한다.
결과 값은 a행×b열인 행렬이다.
normalize(v)
v/ length(v)로 정규화된 벡터 v를 구한다.
v의 길이가 0이면 결과는 정의되지 않는다..
pow(x, y) xy 값을 반환한다.
radians(x) x를 각도에서 호도(radian) 값으로 바꾼다.
reflect(i, n)
반사 벡터 v를 돌려준다. I는 입사 광선, n은 표면의 법선 벡터이라면 결과
값은 v = i 2 * dot(i, n) * n이다.

refract(i, n, eta)
굴절 벡터 v를 구한다(입사 광선은 I이고, 표면의 법선은 n이고, eta는 굴절
색인). eta로 주어진 n과 I 사이의 각도가 너무 크다면 refract는 (0, 0,
0)을 반환한다.
round(x) x에 가장 가까운 정수를 찾는다.
rsqrt(x) 1 / sqrt(x)를 구한다.
saturate(x) x의 값을 [0, 1] 사이가 되게 자른다.
sign(x)
x의 부호를 구한다. x < 0이면 -1을 돌려주고, x=0이면 0을, x > 0이면
1을 돌려준다.
sin(x) x의 사인 값을 구한다.
sincos(x, out s , out c)
x의 사인과 코사인 값을 구한다. sin(x)는 출력 매개변수 s에 저장되고,
cos(x)는 출력 매개변수 c에 저장된다.
sinh(x) x의 하이퍼볼릭 사인을 구한다.
smoothstep(min, max, x)
x < min이라면 0을 반환하고, x > max이면 1을 반환한다. [min, max]
사이에서는 0과 1사이의 smooth Hermite 보간 값을 반환한다.
sqrt(x) 제곱근(성분별).
step(a , x) (x = a) ? 1 : 0 값을 반환한다.
tan(x) x의 탄젠트 값을 구한다.
tanh(x) x에 대한 하이퍼볼릭 탄젠트 값을 구한다.
transpose(m)
행렬 m의 전치 행렬을 구한다. 입력 값이 mro w s × mc o lu m n s 차원이면
출력은 mc o lu m n s ×mrow s 차원의 행렬이 될 것이다.

반응형

'그래픽스(Graphics) > Shader' 카테고리의 다른 글

[소스] 해칭(Hatching) HLSL 소스  (0) 2013.01.05
VS에서 HLSL 편집하기 InteliShade  (0) 2013.01.05
쉐이더 기법  (0) 2012.11.02
smoothstep  (0) 2012.11.02
NVIDIA계열 그래픽카드 오버클럭 하기  (0) 2012.10.31
반응형

Smoothstep 함수 사용법 by 김윤정

smoothstep(min,max,x) : x가 [min, max] 사이의 값인 경우에 대해서 [0, 1] 사이에서 부드럽게 변하는 
Hermite 보간법을 리턴한다. x가 min보다 작다면 0을 리턴하고, max보다 크다면 1을 리턴한다.



..라고 하는데 뭐야 저게... 
라고 해서 알아보니. 

(그림1)

일단 0에서 1로 가는 Liner 한 그래프가 있다고 치죠. 저걸 거꾸로 하면 단순무식한 렘버트 출력값과 같겠죠 (...) 


(그림2)
그리고 min과 max 값을 정합니다. 뭐 이건 0과 1로 정하면 원래 그림인 (그림 1)과 같지만 여기서는 0.2와 0.8로 정했다고 치죠. 

(그림3)

X 값이 min 값보다 작으면 최종 결과는 0 값이 나오고, X 값이 max보다 크면 1값이 나오는건 쉽지요.

(그림4)

근데 만약 X 값이 min과 max 사이에 있는 값이면? 
비율을 다시 계산해서 값을 내놓는다는 것입니다. 그냥 Liner 하게 계산하면 그림과 같겠지요. 
근데 여기서 Hermite Interpolation (보간법)을 사용한다고 합니다. http://en.wikipedia.org/wiki/Hermite_interpolation
... 이거 뭐야 몰라 무서워... 그래픽쟁이한테 이런 수학 공식 들이밀지 마... (이럴때만 그래픽인척 하는 초파리이자 박쥐) 

뭐 그래서 더 생각 안하고, 그림으로 만들어 봤습니다. -_- 
하프 렘버트 출력물을 
밝기에 따라 3단계로 적용. smoothstep 사용. Liner 하지 않다는 것이 보입니다. 
Warp 대용으로 사용한 최종 결과물. 텍스쳐 셈플러 하나 줄였습니다. 만세. 근데 이게 더 무거우면 어쩌지 ㄷㄷㄷ 



즉 아마도 Smoothstep의 보간법은 이런 결과물을 내놓는 듯 합니다. 

(그림5)

반응형

'그래픽스(Graphics) > Shader' 카테고리의 다른 글

[소스] 해칭(Hatching) HLSL 소스  (0) 2013.01.05
VS에서 HLSL 편집하기 InteliShade  (0) 2013.01.05
쉐이더 기법  (0) 2012.11.02
셰이더 내장함수  (0) 2012.11.02
NVIDIA계열 그래픽카드 오버클럭 하기  (0) 2012.10.31
반응형

IDirect3DDevice9::SetScissorRect
Sets the scissor rectangle.

HRESULT SetScissorRect(
  CONST RECT * pRect
);
Parameters
pRect
[in] Pointer to a RECT structure that defines the rendering area within the render target if scissor test is enabled. This parameter may not be NULL.
Return Values
If the method succeeds, the return value is D3D_OK. If the method fails, the return value can be D3DERR_INVALIDCALL.

Remarks
The scissor rectangle is used as a rectangular clipping region.

See Rectangles for further information on the use of rectangles in DirectX.

Requirements
Header: Declared in D3d9.h.

 

 

void Render()

{

    Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
    Device->BeginScene();

 

    // 영역을 지정 한다.
    RECT rect;


    rect.left = 0;
    rect.top = 0;
    rect.right = 400;
    rect.bottom = 400;

 

    // 위에서 영역을 지정 했으면 아래 붉은색의 코드를 넣으면 지정한 영역에만 랜더링 된다.

    Device->SetRenderState( D3DRS_SCISSORTESTENABLE, TRUE );
    Device->SetScissorRect( &rect );

 

    // 아래 for 문은 x 파일을 랜더링 하는 코드이다.

    for( int i = 0; i < Mtrls.size(); i++ )
    {
       Device->SetMaterial( &Mtrls[i] );
       Device->SetTexture( 0, Textures[i] );
       Mesh->DrawSubset( i );
    }

 

    Device->SetRenderState( D3DRS_SCISSORTESTENABLE, FALSE );

 

    Device->EndScene();

}

반응형
반응형

//뷰의 위치로 잡는다
   GetCursorPos(&Pt);
   pMainView->ScreenToClient(&Pt);          //pMainView 뷰클래스
   

반응형
반응형


 m_pDev->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE); 
 m_pDev->SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_ARGB(255,255,255,255));

 m_pDev->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE ); 
 m_pDev->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TFACTOR ); 
 m_pDev->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE ); 
 m_pDev->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); 
 m_pDev->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );


반응형
반응형

D3DXCreateTextureFromFileEx() 함수

송정헌2010-03-12 19:53:37주소복사
조회 764  스크랩 2

01.HRESULT D3DXCreateTextureFromFileEX(
02.       LPDIRECT3DDEVICE9 pDevice,       // 디바이스
03.       LPCTSTR pSrcFile,                  // 텍스쳐 파일 경로
04.       UINT Width,                           // 폭과 높이 0인 경우 파일로부터 취득
05.       UINT Height,                                         
06.       UINT MipLevels,                     // 밉레벨의 수 0인경우 완전한 밉맵체인 
07.       DWORD Usage,                     // 렌더링 타겟으로서 사용
08.       D3DFORMAT Format,              // D3DFORMAT 열거형 멤버
09.       D3DPOOL Pool,                      // 텍스처의 배치처가 되는 메모리 클래스 기술
10.       DWORD Filter,                       // 필터 
11.       DWORD MipFileter,
12.       D3DCOLOR ColorKey,            // 투영이 되는 D3DCOLOR의 값 
13.       D3dXIMAGE_INFO *pSrcInfo,  // 이미지 파일내에 여러 정보 
14.       PALETTEENTRY *pPalette,       // 저장하는 256색 팔레트를 나타내는 포인터
15.      LPDIRECT3DTEXTURE9 *ppTexture
16.);
 
 
 
 
 
==========================================================================================

D3DXCreateTextureFromFileEx를 쓸때 항상 주의하자!

http://telnet.or.kr/directx/graphics/reference/d3dx/functions/texture/d3dxcreatetexturefromfileex.htm

관련 레퍼런스 문서이다.

프로젝트를 진행하다가, D3DXCreateTextureFromFileEx를 이용해 텍스쳐를 불러오는 부분에서 엄청난

오버헤드가 발생하는 것을 발견하였다. 고작 수십 메가바이트의 텍스쳐를 로딩하는 데 10초 가까운 시간이 걸리는 것.



1. 문제점이 저 함수에 있는지를 확인한다.

가장 단순하게, 관련 코드를 주석 처리하고 프로그램을 돌려본다. 로딩이 사라졌다. 역시 저 함수가 문제다.


2. VTune로 어디에서 오버헤드가 걸리는지 확인한다.

확인 결과, 쌩뚱맞은 D3DXSHProjectCubeMap이라는 함수가 cpu clock의 대부분을 소요하고 있다는 사실을 확인하였다.

구글링 결과, 별다른 함수는 아니고, 'VTune 내부의 라이브러리 오류가 아니냐'라는 의견도 보였다. 하지만, 그것은 아닐 테고.

디스어셈블리를 보다, 함수 이름이 명확하게 찍혀 있다. 맞는 함수 같다.


하지만, 프로그램 내부에서 저 함수를 사용한 일은 없다. 다시 문제 해결에 나선다.


3. 레퍼런스를 다시 뜯어본다.

http://telnet.or.kr/directx/graphics/reference/d3dx/functions/texture/d3dxcreatetexturefromfileex.htm

다시 눈을 크게 뜨고 보자. 5번째 parameter에서 밉맵의 깊이를 정한다. 필자가 사용한 코드는,
(필자가 작성한 코드는 아니다. 다른 프로그래머의 코드를 튜닝하고 있던 중이였다.)

hr = D3DXCreateTextureFromFileEx(g_pd3dDevice, token, _textureWidth, _textureHeight, 0, 0,
D3DFMT_UNKNOWN,D3DPOOL_DEFAULT,D3DX_FILTER_BOX | D3DX_FILTER_DITHER, 0, 0, 0, 0, &pTexture);

이다. 5번째 파라미터가 0. 결과적으로 텍스쳐를 불러올 때 마다 완전한 밉맵 체인을 형성한다.


이거야 원. 빨라질래야 빨라질 수가 없다. 1로 바꾼다. 밉맵을 따로 만들지 않는다.


4. 확인.

다시 빌드. 실행. 로딩이 10배는 빨라진 것 같다.

VTune도 잘못된 부분을 집어낸 게 아닌 것 같다. 위에서 나온 D3DXSHProjectCubeMap라는 함수가 밉맵을 형성할 때

내부적으로 호출되는 함수가 아닐까,, 라고 추측해 본다.




5. 결론

레퍼런스. 꼼꼼히 보고 코딩하자. 괜히 피보는 수가 있다.

반응형
반응형

이펙트 렌더링

장치에 이펙트 스테이트를 적용하기 위한 호출의 순서는 다음과 같다 :

  • Begin 은 활성(active) 테크닉을 설정한다.
  • BeginPass 는 활성 패스를 설정한다.
  • CommitChanges 는 패스내에서 모든 설정 호출에 대한 변경을 갱신한다. 이것은 드로우 호출 이전에 호출되어야 한다.
  • EndPass 는 패스를 종료한다.
  • End 는 활성 테크닉을 종료한다.

이펙트 렌더링 코드는 이펙트 없이 렌더링하는 코드보다 더 간단하다. 이펙트를 사용해 렌더링 하는 코드가 다음에 나와 있다 :

// 이펙트에 포함된 테크닉 적용

 


g_pEffect->Begin(&cPasses, 0);

for (iPass = 0; iPass < cPasses; iPass++)
{


g_pEffect->BeginPass(iPass);

// BeginPass 가 호출된 이후 스테이트 변경이 발생했을 때만

// CommitChanges 를 호출한다.
g_pEffect->CommitChanges();

// 적용된 테크닉을 사용해 메시를 렌더링한다.
g_pMesh->DrawSubset(0);

g_pEffect->EndPass();


}


g_pEffect->End();

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

텍스쳐 반투명, 알파값 없는 이미지  (0) 2012.11.02
D3DXCreateTextureFromFileEx() 함수  (0) 2012.11.02
SetRenderState 정리  (0) 2012.11.02
렌더타겟,스텐실  (0) 2012.11.02
DirectX 선그리기  (2) 2012.11.02
반응형

렌더 스테이트 정리

D3DRS_ZENABLE

D3DZBUFFERTYPE 열거형의 1 개의 멤버로서의 깊이 버퍼링 스테이트. z 버퍼링을 유효하게 하려면 D3DZB_TRUE, w 버퍼링을 유효하게 하려면 D3DZB_USEW, 깊이 버퍼링을 무효로 하려면 D3DZB_FALSE 를 각각 설정한다.

D3DPRESENT_PARAMETERS 구조체의 EnableAutoDepthStencil 멤버에 TRUE 를 설정해 스텐실이 스왑 체인과 함께 생성 되고 있는 경우, 이 렌더링 스테이트의 디폴트값은 D3DZB_TRUE, 그렇지 않은 경우는 D3DZB_FALSE 이다.

D3DRS_FILLMODE

D3DFILLMODE 열거형의 1 개 또는 복수의 멤버. 디폴트값은 D3DFILL_SOLID 이다.

D3DRS_SHADEMODE

D3DSHADEMODE 열거형의 1 개 또는 복수의 멤버. 디폴트값은 D3DSHADE_GOURAUD 이다.

D3DRS_ZWRITEENABLE

애플리케이션에 의한 깊이 버퍼에의 쓰기를 유효하게 하려면 , TRUE 를 설정한다. 디폴트값은 TRUE 이다. 애플리케이션은 이 멤버를 이용하는 것으로써, 시스템이 새로운 깊이값으로 깊이 버퍼를 갱신하는 것을 막을 수가 있다. FALSE 의 경우는, 렌더링 스테이트 D3DRS_ZFUNC (깊이 버퍼링을 하고 있으면 가정)에 따라 깊이 비교가 실행되지만, 깊이값은 버퍼에 기입해지지 않다.

D3DRS_ALPHATESTENABLE

픽셀마다 알파 테스트를 유효하게 하려면 , TRUE 를 설정한다. 테스트가 성공하면 픽셀이 frame buffer에 의해 처리된다. 실패 하면, 그 픽셀의 모든 frame buffer 처리는 스킵 된다.

D3DRS_ALPHAFUNC 렌더링 스테이트에 의해 제공되는 비교 함수를 사용해, 들어 오는 알파값을 기준 알파값과 비교해 테스트를 실시한다. 기준 알파값은,D3DRS_ALPHAREF 의 설정값으로 정해진다. 더 자세한 정보는, 「알파 실험 스테이트」를 참조할것.

이 파라미터의 디폴트값은 FALSE 이다.

D3DRS_LASTPIXEL

디폴트값은 TRUE 이며, 선으로 마지막 픽셀의 드로잉(Drawing)를 유효하게 한다. 마지막 픽셀을 드로잉(Drawing) 하지 않게 하려면 , 이 값을 FALSE 로 설정한다. 더 자세한 정보는, 「아우트라인 및 전부 칠해 스테이트」를 참조할것.

D3DRS_SRCBLEND

D3DBLEND 열거형의 멤버중 하나이다. 디폴트값은 D3DBLEND_ONE 이다.

D3DRS_DESTBLEND

D3DBLEND 열거형의 멤버중 하나이다. 디폴트값은 D3DBLEND_ZERO 이다.

D3DRS_CULLMODE

뒷면의 삼각형을 컬링(Culling) 하는 경우에, 그방법을 지정한다. D3DCULL 열거형의 멤버의 어느쪽이든을 설정할 수 있다. 디폴트값은 D3DCULL_CCW 이다.

D3DRS_ZFUNC

D3DCMPFUNC 열거형의 멤버중 하나이다. 디폴트값은 D3DCMP_LESSEQUAL 이다. 이 멤버는, 애플리케이션에카메라로부터의 거리를 기준으로 하는 픽셀의 수취나 받아 거부를 허가한다.

픽셀의 깊이값을 깊이 버퍼의 값과 비교한다. 픽셀의 깊이값이 비교 함수로 허가되었을 경우는, 픽셀이 써진다.

깊이값이 깊이 버퍼에 써넣어지는 것은, 렌더링 스테이트가 TRUE 의 경우 뿐이다.

이 깊이 테스트에 실패하는 쪽이, 소프트웨어에 의한 래스터화나 많은 하드웨어 가속기의 처리는 빨라진다. 이것은, 픽셀의 렌더링 처리를 실시하지 않는 경우에, 텍스처를 필터 처리하거나 곱셈하거나 할 필요가 없어지기 때문에 있다.

D3DRS_ALPHAREF

알파 테스트가 유효하게 설정되어 있는 경우에, 픽셀을 테스트하기 위한 기준 알파값을 지정하는 값. 이것은,DWORD 렌더링 스테이트값의 하위 8 비트에 해당하는 8 비트값이다. 값은 0x00000000 에서 0x000000FF 의 범위내이다. 디폴트값은 0 이다.

D3DRS_ALPHAFUNC

D3DCMPFUNC 열거형의 멤버중 하나이다. 디폴트값은, D3DCMP_ALWAYS 이다. 이 멤버는, 애플리케이션에 알파값을 기준으로 하는 픽셀의 수취나 받아 거부를 허가한다.

D3DRS_DITHERENABLE

디더 링을 유효하게 하려면 , TRUE 를 설정한다. 디폴트값은 FALSE 이다.

D3DRS_ALPHABLENDENABLE

알파 블렌드에 의한 투명화를 유효하게 하려면 , TRUE 를 설정한다. 디폴트값은 FALSE 이다.

알파 혼합의 타입은, D3DRS_SRCBLEND 와 D3DRS_DESTBLEND 의 렌더링 스테이트에 의해 정해진다.

D3DRS_FOGENABLE

포그(안개:fog) 혼합을 유효하게 하려면 , TRUE 를 설정한다. 디폴트값은 FALSE 이다. 포그(안개:fog) 혼합의 사용법의 더 자세한 정보는, 「포그(안개:fog)」를 참조할것.

D3DRS_SPECULARENABLE

스펙큐러 하이라이트를 유효하게 하려면 , TRUE 를 설정한다. 디폴트값은 FALSE 이다.

스펙큐러 하이라이트는, 빛이 맞고 있는 개체의 각 정점이 그 개체의 원점에 있는것 같이 산출된다. 이것에 의해, 개체가 원점의 주위로 모델화 되어 광원과 개체간의 거리가 비교적 큰 경우에 한정해, 결과를 예측할 수가 있다. 그 이외의 경우, 결과는 부정이다.

이 멤버에 TRUE 를 설정 하면, 텍스처 cascade 후, 알파 혼합전에, 베이스 컬러에 스펙큐러색이 추가된다.

D3DRS_FOGCOLOR

D3DCOLOR 형의 값. 디폴트값은 0 이다. 포그(안개:fog) 컬러의 더 자세한 정보는, 「포그(안개:fog)색」을 참조할것.

D3DRS_FOGTABLEMODE

픽셀 포그(안개:fog)에 사용되는 포그(안개:fog)식. D3DFOGMODE 열거형의 멤버의 어느쪽이든을 설정한다. 디폴트값은 D3DFOG_NONE 이다. 픽셀 포그(안개:fog)의 더 자세한 정보는, 「픽셀 포그(안개:fog)」를 참조할것.

D3DRS_FOGSTART

선형 포그(안개:fog) 모드로, 픽셀 또는 정점 포그(안개:fog) 이펙트가 시작 하는 깊이. 디폴트값은 0.0f 이다. 깊이는, 정점 포그(안개:fog)의 경우는 월드 공간에서, 픽셀 포그(안개:fog)의 경우는 장치 공간 [0.0, 1.0] 또는 월드 공간의 어느쪽이든으로 지정한다. 픽셀 포그(안개:fog)에서는, 포그(안개:fog) 계산에 z 를 사용하는 경우, 이러한 값은 장치 공간에 있어, 시점과의 상대 포그(안개:fog) (w 포그(안개:fog))를 사용하는 경우는 월드 공간에 있다. 더 자세한 정보는, 「포그(안개:fog) 파라미터」 및 「시점으로부터의 상대 깊이대 Z 베이스의 깊이」를 참조할것.

이 렌더링 스테이트의 값은 부동 소수점값이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_FOGSTART, *((DWORD*) (&fFogStart)));

D3DRS_FOGEND

선형 포그(안개:fog) 모드로, 픽셀 또는 정점 포그(안개:fog) 이펙트가 종료하는 깊이. 디폴트값은 1.0f 이다. 깊이는, 정점 포그(안개:fog)의 경우는 월드 공간에서, 픽셀 포그(안개:fog)의 경우는 장치 공간 [0.0, 1.0] 또는 월드 공간의 어느쪽이든으로 지정한다. 픽셀 포그(안개:fog)에서는, 포그(안개:fog) 계산에 z 를 사용하는 경우, 이러한 값은 장치 공간에 있어, 시점과의 상대 포그(안개:fog) (w 포그(안개:fog))를 사용하는 경우는 월드 공간에 있다. 더 자세한 정보는, 「포그(안개:fog) 파라미터」 및 「시점으로부터의 상대 깊이대 Z 베이스의 깊이」를 참조할것.

이 렌더링 스테이트의 값은 부동 소수점값이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_FOGEND, *((DWORD*) (&fFogEnd)));

D3DRS_FOGDENSITY

지수 포그(안개:fog) 모드 (D3DFOG_EXP 및 D3DFOG_EXP2)로 사용하는 픽셀 또는 정점 포그(안개:fog)의 포그(안개:fog) 밀도. 유효한 밀도의 값은 0.0 에서 1.0 의 범위내이다. 디폴트값은 1.0 이다. 더 자세한 정보는, 「포그(안개:fog) 파라미터」를 참조할것.

이 렌더링 스테이트의 값은 부동 소수점값이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_FOGDENSITY, *((DWORD*) (&fFogDensity)));

D3DRS_RANGEFOGENABLE

범위 베이스의 정점 포그(안개:fog)를 유효하게 하려면 , TRUE 를 설정한다. 디폴트값은 FALSE 로, 시스템은 깊이 베이스의 포그(안개:fog)를 사용한다. 범위 베이스의 포그(안개:fog)에서는, 장면(scene)에 있어서의 개체의 깊이 (z 좌표)는 아니고, 뷰어로부터의 개체의 거리로 포그(안개:fog) 이펙트를 계산한다. 범위 베이스의 포그(안개:fog)에서는, 보통의 모든 포그(안개:fog) 메서드가 기능하지만, 깊이는 아니고 범위를 사용해 계산을 실시하는 점만이 다르다.

범위는 포그(안개:fog) 계산에 사용하는 적절한 요소이지만, 범위는 계산에 시간이 걸려, 깊이는 보통 계산이 끝난 상태이므로, 대신에 깊이가 넓게 사용된다. 깊이를 사용해 포그(안개:fog)를 계산 하면, 주변 개체의 포그(안개:fog) 이펙트가 시점의 이동과 함께 변화 하면 말하는 바람직하지 않은 영향이 나온다. 이 경우, 깊이는 변화하지만 범위는 일정한 까지 있다.

현재로서는, 픽셀 단위의 범위 베이스의 포그(안개:fog)를 지원 하는 하드웨어는 존재하지 않기 때문에, 범위 보정은 정점 포그(안개:fog)에서만 행해진다.

더 자세한 정보는, 「정점 포그(안개:fog)」를 참조할것.

D3DRS_STENCILENABLE

스텐실 처리를 유효하게 하려면 TRUE 를 설정해, 스텐실 처리를 무효로 하려면 FALSE 를 설정한다. 디폴트값은 FALSE 이다.

더 자세한 정보는, 「스텐실 버퍼 테크닉」을 참조할것.

D3DRS_STENCILFAIL

스텐실 테스트에 실패했을 때에 실행하는 스텐실 처리. 이것에는 D3DSTENCILCAPS 의 몇개의 정수를 설정할 수 있다. 디폴트값은 D3DSTENCILOP_KEEP 이다.

더 자세한 정보는, 「스텐실 버퍼 테크닉」을 참조할것.

D3DRS_STENCILZFAIL

스텐실 테스트에 패스해, 깊이 테스트 (Z 테스트)에 실패했을 경우에 실행하는 스텐실 처리. 이것에는 D3DSTENCILCAPS 의 몇개의 정수를 설정할 수 있다. 디폴트값은 D3DSTENCILOP_KEEP 이다.

D3DRS_STENCILPASS

스텐실 테스트 및 깊이 (Z) 테스트의 양쪽 모두에 패스했을 경우에 실행하는 스텐실 처리. 이것에는 D3DSTENCILCAPS 의 몇개의 정수를 설정할 수 있다. 디폴트값은 D3DSTENCILOP_KEEP 이다.

D3DRS_STENCILFUNC

스텐실 테스트를 위한 비교 함수. 이것에는 D3DCMPFUNC 열거형의 멤버의 어느쪽이든을 설정할 수 있다. 디폴트값은, D3DCMP_ALWAYS 이다.

비교 함수는, 스텐실 버퍼의 요소를 기준치와 비교하기 위해서(때문에) 사용된다. 이 비교는, 기준치의 비트, 및 스텐실 마스크 (D3DRS_STENCILMASK 렌더링 스테이트에 의해 설정)로 설정된 스텐실 버퍼 요소에만 적용된다. TRUE 의 경우는, 스텐실 테스트에 패스한다.

D3DRS_STENCILREF

스텐실 테스트를 위한 int 기준치. 디폴트값은 0 이다.

D3DRS_STENCILMASK

기준치 및 각 스텐실 버퍼 요소에 적용해, 스텐실 테스트를 위한 유효 비트를 결정하는 마스크. 디폴트 마스크는 0xFFFFFFFF 이다.

D3DRS_STENCILWRITEMASK

스텐실 버퍼에 기입하는 값에 적용하는 쓰기 마스크. 디폴트 마스크는 0xFFFFFFFF 이다.

D3DRS_TEXTUREFACTOR

D3DTA_TFACTOR 텍스처 혼합 인수 또는 D3DTOP_BLENDFACTORALPHA 텍스처 혼합 처리에 의한 멀티 텍스처 혼합으로 사용되는 색. 관련하는 값은 D3DCOLOR변수이다. 디폴트값은 불투명의 흰색 (0xFFFFFFFF)이다.

D3DRS_WRAP0

복수의 텍스처 좌표 세트에 대한 텍스처 랩핑 동작. 이 렌더링 스테이트의 유효값으로 D3DWRAPCOORD_0 (또는 D3DWRAP_U), D3DWRAPCOORD_1 (또는 D3DWRAP_V), D3DWRAPCOORD_2 (또는 D3DWRAP_W), 및 D3DWRAPCOORD_3 의 각 플래그를 조합할 수가 있다. 이러한 값을 설정 하면, 지정된 텍스처에 대해서 1, 2, 3, 및 4 차원 방향 (s, t, r, 및 q 방향으로 불리는 경우도 있다)의 랩핑이 실행된다. 이 렌더링 스테이트의 디폴트값은 0 이다 (전방향의 랩핑이 무효).

D3DRS_WRAP1

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP2

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP3

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP4

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP5

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP6

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP7

D3DRS_WRAP0 」를 참조할것.

D3DRS_CLIPPING

Microsoft® Direct3D® 에 의한 기본도형의 클리핑을 유효하게 하려면 TRUE, 무효로 하려면 FALSE 를 설정한다. 디폴트값은 TRUE 이다.

D3DRS_LIGHTING

Direct3D 의 조명을 유효하게 하려면 TRUE, 무효로 하려면 FALSE 를 설정한다. 디폴트값은 TRUE 이다. 정점 법선을 포함한 정점만 올바르게 라이트가 댈 수 있어 법선을 포함하지 않는 정점에서는 모든 조명 계산으로 0 의 내적이 사용된다.

D3DRS_AMBIENT

앰비언트 라이트의 색. 이 값은 D3DCOLOR 형이다. 디폴트값은 0 이다.

D3DRS_FOGVERTEXMODE

정점 포그(안개:fog)로 사용되는 포그(안개:fog)식. D3DFOGMODE 열거형의 멤버의 어느쪽이든을 설정한다. 디폴트값은 D3DFOG_NONE 이다.

D3DRS_COLORVERTEX

정점 단위의 색을 유효하게 하려면 TRUE, 무효로 하려면 FALSE 를 설정한다. 디폴트값은 TRUE 이다. 정점 단위의 색을 유효하게 하면, 각 정점에 정의된 색을 조명 계산으로 사용할 수 있다.

더 자세한 정보는, 이하의 렌더링 스테이트를 참조할것.

D3DRS_LOCALVIEWER

카메라와의 상대 각도에 의존한 스펙큐러 하이라이트를 유효하게 하려면 TRUE 를 설정해, 정스펙큐러 하이라이트를 사용하려면 FALSE 를 설정한다. 디폴트값은 TRUE 이다. 정사영을 사용하는 애플리케이션에서는 FALSE 를 설정하는 것.

D3DRS_NORMALIZENORMALS

정점 법선의 자동 정규화를 유효하게 하려면 TRUE, 무효로 하려면 FALSE 를 설정한다. 디폴트값은 FALSE 이다. 이 기능을 유효하게 하면, 정점이 카메라 공간에 변환 된 다음에 정점 법선이 정규화되지만, 계산에 시간이 걸린다.

D3DRS_DIFFUSEMATERIALSOURCE

조명 계산에 사용되는 디퓨즈색의 소스. 유효한 값은,D3DMATERIALCOLORSOURCE 열거형의 멤버이다. 디폴트값은 D3DMCS_COLOR1 이다. 이 렌더링 스테이트의 값이 사용되는 것은, D3DRS_COLORVERTEX 렌더링 스테이트가 TRUE 로 설정되어 있는 경우 뿐이다.

D3DRS_SPECULARMATERIALSOURCE

조명 계산에 사용되는 스펙큐러색의 소스. 유효한 값은,D3DMATERIALCOLORSOURCE 열거형의 멤버이다. 디폴트값은 D3DMCS_COLOR2 이다.

D3DRS_AMBIENTMATERIALSOURCE

조명 계산에 사용되는 앰비언트색의 소스. 유효한 값은,D3DMATERIALCOLORSOURCE 열거형의 멤버이다. 디폴트값은 D3DMCS_MATERIAL 이다.

D3DRS_EMISSIVEMATERIALSOURCE

조명 계산에 사용되는 에미션(emission)색의 소스. 유효한 값은,D3DMATERIALCOLORSOURCE 열거형의 멤버이다. 디폴트값은 D3DMCS_MATERIAL 이다.

D3DRS_VERTEXBLEND

지오메트리가 있는 경우, 지오메트리 혼합을 실행하기 위해서 사용하는 행렬의 개수. 유효한 값은,D3DVERTEXBLENDFLAGS 열거형의 멤버이다. 디폴트값은 D3DVBF_DISABLE 이다.

D3DRS_CLIPPLANEENABLE

사용자 정의의 클립면을 유효 또는 무효로 한다. 유효한 값은, 각 비트의 스테이터스 (설정의 유무)에 의해 대응하는 사용자 정의 클립면을 액티브하게 하는 스테이트를 바꾸는, 임의의 DWORD 이다. 최하정도 비트 (비트 0)는 인덱스 0 의 최초의 클립면을 제어해, 후속 비트는 그것보다 상위의 인덱스의 클립면을 액티브하게 하는 것을 제어한다. 비트가 설정되어 있는 경우, 장면(scene)의 렌더링중에 적절한 클립면이 적용된다. 디폴트값은 0 이다.

클립면을 간단하게 유효하게 할 수 있도록(듯이) D3DCLIPPLANEn 매크로가 정의되고 있다.

D3DRS_POINTSIZE

각 정점에 대해서 포인트 사이즈가 지정되지 않은 경우에, 포인트 사이즈 계산으로 사용하는 사이즈를 지정하는 float 값. 정점이 포인트 사이즈를 포함하고 있는 경우, 이 값은 사용되지 않는다. 이 값은, D3DRS_POINTSCALEENABLE 가 FALSE 의 경우는 스크린 공간 단위로 지정한다. 그 이외의 경우는, 월드 공간 단위로 지정한다. 디폴트값은 1.0f 이다. 이 값의 범위는, 0.0f 이상이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_POINTSIZE, *((DWORD*) &PointSize));

D3DRS_POINTSIZE_MIN

포인트 기본도형의 최소 사이즈를 지정하는 float 값. 렌더링의 사이, 포인트 기본도형는 이 사이즈에 고정된다. 1.0 보다 작은 값을 설정 하면, 포인트에 픽셀의 중심이 포함되지 않고 anti-aliasing가 무효가 되어 있는 경우는 포인트가 표시되지 않게 되어, anti-aliasing가 유효하게 되어 있는 경우는 낮은 휘도(Luminance)로 렌더링 된다. 디폴트값은 1.0f 이다. 이 값의 범위는, 0.0f 이상이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_POINTSIZE_MIN, *((DWORD*) &PointSizeMin));

D3DRS_POINTSPRITEENABLE

BOOL 값. TRUE 를 설정 하면, 텍스처 전체가 각 포인트에 맵핑 되도록(듯이), 포인트 기본도형의 텍스처 좌표가 설정된다. FALSE 를 설정 하면, 정점의 텍스처 좌표가 포인트 전체에 대해서 사용된다. 디폴트값은 FALSE 이다. D3DRS_POINTSCALEENABLE 에 FALSE (디폴트값)를 설정해, D3DRS_POINTSIZE 에 1.0 (디폴트값)을 설정하는 것으로, Microsoft DirectX® 7.0 스타일의 1 픽셀의 포인트를 실현할 수 있다.

D3DRS_POINTSCALEENABLE

포인트 기본도형에 대한 사이즈의 계산을 제어하는 BOOL 값. TRUE 를 설정 하면, 포인트 사이즈를 카메라 공간의 값으로 해석해, 거리 함수 및 절두체에 의해 뷰포트의 y 축의 스케일에 맞추어 조정해, 최종적인 스크린 공간의 포인트 사이즈를 계산한다. FALSE 를 설정 하면, 포인트 사이즈는 스크린 공간의 값이라고 해석되어, 그대로 사용된다. 디폴트값은 FALSE 이다.

D3DRS_POINTSCALE_A

포인트 기본도형에 대한 거리 베이스의 사이즈의 감쇠를 제어하는 float 값. D3DRS_POINTSCALEENABLE 가 TRUE 의 경우에만 유효하다. 디폴트값은 1.0f 이다. 이 값의 범위는, 0.0f 이상이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_POINTSCALE_A, *((DWORD*) &PointScaleA));

D3DRS_POINTSCALE_B

포인트 기본도형에 대한 거리 베이스의 사이즈의 감쇠를 제어하는 float 값. D3DRS_POINTSCALEENABLE 가 TRUE 의 경우에만 유효하다. 디폴트값은 0.0f 이다. 이 값의 범위는, 0.0f 이상이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_POINTSCALE_B, *((DWORD*) &PointScaleB));

D3DRS_POINTSCALE_C

포인트 기본도형에 대한 거리 베이스의 사이즈의 감쇠를 제어하는 float 값. D3DRS_POINTSCALEENABLE 가 TRUE 의 경우에만 유효하다. 디폴트값은 0.0f 이다. 이 값의 범위는, 0.0f 이상이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_POINTSCALE_C, *((DWORD*) &PointScaleC));

D3DRS_MULTISAMPLEANTIALIAS

멀티 샘플 렌더링의 타겟 버퍼를 사용할 때의, 각각의 샘플의 계산방법을 결정하는 BOOL 값. TRUE 를 설정 하면, 복수 샘플의 각각 붙어 다른 샘플링 위치에서 샘플링 하는 것으로 풀 신 anti-aliasing를 실행하도록(듯이), 복수의 샘플이 계산된다. FALSE 의 경우는, 복수의 샘플은 모두 같은 샘플링값 (픽셀의 중심으로 샘플링 된 값)으로 기술되어, 멀티 샘플 버퍼에 대한 비anti-aliasing 렌더링이 가능하게 된다. 싱글 샘플 버퍼에의 렌더링시, 이 렌더링 스테이트는 이펙트를 가지지 않는다. 디폴트값은 TRUE 이다.

D3DRS_MULTISAMPLEMASK

최하정도 비트 (LSB)를 선두로 하는 이 마스크의 각 비트는, 멀티 샘플 렌더링 타겟의 1 개의 샘플에 대한 변경을 제어한다. 따라서, 8 샘플의 렌더링 타겟의 경우는, 8 개의 샘플의 각각 대하는 8 개의 쓰기 허가 정보가, 하위 바이트에 저장 되고 있다. 싱글 샘플 버퍼에의 렌더링시, 이 렌더링 스테이트는 이펙트를 가지지 않는다. 디폴트값은 0xFFFFFFFF 이다.

이 렌더링 스테이트를 사용하면 멀티 샘플 버퍼를 축적 버퍼로서 사용해, 각 패스가 샘플의 서브 세트를 갱신하는 것 같은 지오메트리의 멀티 패스 렌더링을 실시할 수가 있다.

이 렌더링 스테이트는,D3DCAPS9 구조체의 D3DPRASTERCAPS_STRETCHBLTMULTISAMPLE 멤버가 유효하게 되어 있는 경우는 지원 되지 않는다.

멀티 샘플수가 n, 유효 샘플수가 k 인 경우, 이미지는 k/n 의 휘도(Luminance)로 렌더링 된다. 각 픽셀의 각 성분 RGB 는,k/n 를 계수에 갖는다.

D3DRS_PATCHEDGESTYLE

패치 엣지가 부동 소수점수(실수) 스타일의 테설레이션을 사용할지 어떨지를 설정한다. 설정 가능한 값은,D3DPATCHEDGESTYLE 열거형으로 정의된다. 디폴트값은 D3DPATCHEDGE_DISCRETE 이다.

D3DRS_DEBUGMONITORTOKEN

모니터를 디버그 하는 경우에만 설정한다. 설정 가능한 값은,D3DDEBUGMONITORTOKENS 열거형으로 정의된다. D3DRS_DEBUGMONITORTOKEN 가 설정되어 있는 경우, 이 호출은 디버그 모니터에의 토큰의 수수로서 처리되는 것에 주의 해야 한다. 예를 들어, D3DDMT_ENABLE 또는 D3DDMT_DISABLE 을 D3DRS_DEBUGMONITORTOKEN 에 건네준 후, 다른 토큰의 값이 건네받았을 경우, 디버그 모니터의 스테이트 (유효 또는 무효)는 변화하지 않는다.

이 스테이트는, 디버그 빌드에서만 유용하다. 디버그 모니터의 디폴트는 D3DDMT_ENABLE 이다.

D3DRS_POINTSIZE_MAX

포인트 스프라이트가 제한되는 최대 사이즈를 지정하는 float 값. 값은,D3DCAPS9 의 MaxPointSize 멤버 이하로,D3DRS_POINTSIZE_MIN 이상이 아니면 안된다. 디폴트값은 64.0f 이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_PONTSIZE_MAX, *((DWORD*) &PointSizeMax));

D3DRS_INDEXEDVERTEXBLENDENABLE

인덱스 첨부의 정점 혼합을 유효 또는 무효로 하는 BOOL 값. 디폴트값은 FALSE 이다. TRUE 를 설정 하면, 인덱스 첨부 정점 혼합이 유효하게 된다. FALSE 를 설정 하면, 인덱스 첨부 정점 혼합은 무효가 된다. 이 렌더링 스테이트가 유효한 경우는, 정점 마다 팩 된 DWORD 로 행렬 인덱스를 건네주지 않으면 안 된다. 이 렌더링 스테이트를 무효로 해, D3DRS_VERTEXBLEND 스테이트를 사용해 정점 혼합을 유효하게 하는 것은, 모든 정점에 대해 행렬 인덱스 0, 1, 2, 3 을 지정하는 것과 같다.

D3DRS_COLORWRITEENABLE

렌더링 타겟의 컬러 버퍼에 대한 채널마다 쓰기를 유효하게 하는 UINT 값. 비트를 설정 하면, 3D 렌더링의 사이에 컬러 채널이 갱신된다. 비트를 클리어 하면, 컬러 채널은 갱신되지 않는다. 이 기능은, 장치에 대한 D3DCAPS9 구조체의 PrimitiveMiscCaps 멤버로 D3DPMISCCAPS_COLORWRITEENABLE 능력 비트가 설정되어 있는 경우에 이용할 수 있다. 이 렌더링 스테이트는, 클리어 처리에는 영향을 주지 않는다. 디폴트값은 0x0000000F 이다.

이 렌더링 스테이트에 대한 유효한 값은, D3DCOLORWRITEENABLE_ALPHA, D3DCOLORWRITEENABLE_BLUE, D3DCOLORWRITEENABLE_GREEN, 및 D3DCOLORWRITEENABLE_RED 의 각 플래그의 임의의 편성이다.

D3DRS_TWEENFACTOR

트인 계수를 제어하는 float 값. 디폴트값은 0.0f 이다. IDirect3DDevice9::SetRenderState 메서드는 DWORD 값을 사용하기 (위해)때문에, 다음 코드에 나타나듯이 애플리케이션에서는 값을 저장 한 변수를 캐스트 해야 한다.

pDevice9->SetRenderState(D3DRS_TWEENFACTOR, *((DWORD*) &TweenFactor));

D3DRS_BLENDOP

알파 혼합 렌더링 스테이트의 D3DRS_ALPHABLENDENABLE 가 TRUE 로 설정되어 있는 경우에 적용하는 산술 연산의 선택에 사용되는 값. 유효한 값은,D3DBLENDOP 열거형으로 정의된다. 디폴트값은 D3DBLENDOP_ADD 이다.

D3DPMISCCAPS_BLENDOP 장치 능력이 지원되지 않은 경우는, D3DBLENDOP_ADD 가 실행된다.

D3DRS_POSITIONDEGREE

N 패치 위치 보간 차수. 이 값에는 D3DDEGREE_CUBIC (디폴트) 또는 D3DDEGREE_LINEAR 를 설정할 수 있다. 더 자세한 정보는, 「D3DDEGREETYPE 」를 참조할것.

D3DRS_NORMALDEGREE

N 패치 법선 보간 차수. 이 값에는 D3DDEGREE_LINEAR (디폴트) 또는 D3DDEGREE_QUADRATIC 를 설정할 수 있다. 더 자세한 정보는, 「D3DDEGREETYPE 」를 참조할것.

D3DRS_SCISSORTESTENABLE

시저 테스트를 유효하게 하려면 TRUE, 무효로 하려면 FALSE 를 설정한다. 디폴트값은 FALSE 이다.

D3DRS_SLOPESCALEDEPTHBIAS

z 화이팅을 줄이기 위해서(때문에), 동일 평면상의 원시적으로 얼마나 바이어스를 적용할까를 결정하는데 사용한다. 디폴트값은 0 이다.

bias = (max * D3DRS_SLOPESCALEDEPTHBIAS ) + D3DRS_DEPTHBIAS

여기서, max 는 렌더링 하는 삼각형의 최대 깊이 구배.

D3DRS_ANTIALIASEDLINEENABLE

선의 anti-aliasing를 유효하게 하는 경우는 TRUE, 무효로 하는 경우는 FALSE 를 설정한다. 디폴트값은 FALSE 이다.

멀티 샘플 렌더링 타겟을 렌더링 하는 경우, D3DRS_ANTIALIASEDLINEENABLE 는 무시되어 모든 선이 깔쭉깔쭉하게 렌더링 된다. 멀티 샘플 렌더링 타겟으로 라인의 anti-aliasing를 유효하게 하려면 ,ID3DXLine 를 사용한다.

D3DRS_MINTESSELLATIONLEVEL

테설레이션의 최소 레벨. 디폴트값은 1.0f 이다. 「테설레이션」을 참조할것.

D3DRS_MAXTESSELLATIONLEVEL

테설레이션의 최대 레벨. 디폴트값은 1.0f 이다. 「테설레이션」을 참조할것.

D3DRS_ADAPTIVETESS_X

적응형 테설레이션의 양 (x 축방향). 디폴트값은 0.0f 이다. 「테설레이션」을 참조할것.

D3DRS_ADAPTIVETESS_Y

적응형 테설레이션의 양 (y 축방향). 디폴트값은 0.0f 이다. 「테설레이션」을 참조할것.

D3DRS_ADAPTIVETESS_Z

적응형 테설레이션의 양 (z 축방향). 디폴트값은 1.0f 이다. 「테설레이션」을 참조할것.

D3DRS_ADAPTIVETESS_W

적응형 테설레이션의 양 (w 축방향). 디폴트값은 0.0f 이다. 「테설레이션」을 참조할것.

D3DRS_ENABLEADAPTIVETESSELATION

적응형 테설레이션을 유효하게 하려면 TRUE, 무효로 하려면 FALSE 를 설정한다. 디폴트값은 FALSE 이다. 「테설레이션」을 참조할것.

D3DRS_TWOSIDEDSTENCILMODE

2 면의 스텐실을 유효하게 하려면 TRUE, 무효로 하려면 FALSE 를 설정한다. 디폴트값은 FALSE 이다. 애플리케이션에서는, 2 면의 스텐실 모드를 유효하게 하려면 D3DRS_CULLMODE 를 D3DCULL_NONE 로 설정할 필요가 있다. 삼각형의 와인딘그 순서가 시계회전인 경우는, D3DRS_STENCIL* 의 조작이 사용된다. 와인딘그 순서가 반시계 주위인 경우는, D3DRS_CCW_STENCIL* 의 조작이 사용된다.

2 면의 스텐실이 지원 되고 있는지를 확인하려면 , D3DSTENCILCAPS_TWOSIDED 의 D3DCAPS9 의 StencilCaps 멤버를 조사한다. 「D3DSTENCILCAPS 」도 참조할것.

D3DRS_CCW_STENCILFAIL

반시계회전의 스텐실 테스트에 실패했을 때에 실행하는 스텐실 처리. 디폴트값은 0x00000001 이다.

D3DRS_CCW_STENCILZFAIL

반시계회전의 스텐실 테스트에 패스해, Z 테스트에 실패했을 경우에 실행하는 스텐실 처리. 디폴트값은 0x00000001 이다.

D3DRS_CCW_STENCILPASS

반시계회전의 스텐실 테스트 및 Z 테스트의 양쪽 모두에 패스했을 경우에 실행하는 스텐실 처리. 디폴트값은 0x00000001 이다.

D3DRS_CCW_STENCILFUNC

비교 함수. 반시계회전의 스텐실 테스트에 패스하는 것은, ((ref & mask) 스텐실 함수 (stencil & mask))가 TRUE 의 경우이다. 디폴트값은 0x00000008 이다.

D3DRS_COLORWRITEENABLE1

장치에 대한 추가의 ColorWriteEnable 의 값. 「D3DRS_COLORWRITEENABLE 」를 참조할것. 이 기능은, 장치에 대한 D3DCAPS9 구조체의 PrimitiveMiscCaps 멤버로 D3DPMISCCAPS_INDEPENDENTWRITEMASKS 능력 비트가 설정되어 있는 경우에 이용할 수 있다. 디폴트값은 0x0000000f 이다.

D3DRS_COLORWRITEENABLE2

장치에 대한 추가의 ColorWriteEnable 의 값. 「D3DRS_COLORWRITEENABLE 」를 참조할것. 이 기능은, 장치에 대한 D3DCAPS9 구조체의 PrimitiveMiscCaps 멤버로 D3DPMISCCAPS_INDEPENDENTWRITEMASKS 능력 비트가 설정되어 있는 경우에 이용할 수 있다. 디폴트값은 0x0000000f 이다.

D3DRS_COLORWRITEENABLE3

장치에 대한 추가의 ColorWriteEnable 의 값. 「D3DRS_COLORWRITEENABLE 」를 참조할것. 이 기능은, 장치에 대한 D3DCAPS9 구조체의 PrimitiveMiscCaps 멤버로 D3DPMISCCAPS_INDEPENDENTWRITEMASKS 능력 비트가 설정되어 있는 경우에 이용할 수 있다. 디폴트값은 0x0000000f 이다.

D3DRS_BLENDFACTOR

알파 혼합 처리동안에 정수 혼합 계수에 사용하는 D3DCOLOR . 이 기능은,D3DCAPS9 의 SrcBlendCaps 멤버, 또는 D3DCAPS9 의 DestBlendCaps 멤버로 D3DPBLENDCAPS_BLENDFACTOR 능력 플래그가 설정되어 있는 경우에 이용할 수 있다. 「D3DRENDERSTATETYPE」를 참조할것. 디폴트값은 0xffffffff 이다.

D3DRS_SRGBWRITEENABLE

렌더링 타겟에의 쓰기로, sRGB 에의 감마 보정을 유효하게 한다. 포맷에서는,D3DUSAGE_SRGBWRITE 를 공개할 필요가 있다. 디폴트값은 0 이다.

D3DRS_DEPTHBIAS

깊이값의 비교에 사용하는 부동 소수점값. 「깊이 바이어스」를 참조할것. 디폴트값은 0 이다.

D3DRS_WRAP8

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP9

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP10

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP11

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP12

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP13

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP14

D3DRS_WRAP0 」를 참조할것.

D3DRS_WRAP15

D3DRS_WRAP0 」를 참조할것.

D3DRS_SEPARATEALPHABLENDENABLE

TRUE 를 설정 하면, 알파 채널에 대한 개별의 혼합 모드가 유효하게 된다. 디폴트값은 FALSE 이다.

FALSE 를 설정 하면, 알파에 적용하는 렌더링 타겟의 혼합 계수와 혼합 처리는, 강제적으로, 색에 대해서 정의한 것 것과 같은 것이 된다. D3DPMISCCAPS_SEPARATEALPHABLEND 능력을 설정하지 않는 처리에서는, 이 모드가 실질적으로 FALSE 에 고정된다. 「D3DPMISCCAPS 」를 참조할것.

개별의 알파 혼합의 타입은, D3DRS_SRCBLENDALPHA 와 D3DRS_DESTBLENDALPHA 의 렌더링 스테이트에 의해 정해진다.

D3DRS_SRCBLENDALPHA

D3DBLEND 열거형의 멤버중 하나이다. D3DRS_SEPARATEALPHAENABLE 가 TRUE 가 아닌 경우, 이 값은 무시된다. 디폴트값은 D3DBLEND_ONE 이다.

D3DRS_DESTBLENDALPHA

D3DBLEND 열거형의 멤버중 하나이다. D3DRS_SEPARATEALPHAENABLE 가 TRUE 가 아닌 경우, 이 값은 무시된다. 디폴트값은 D3DBLEND_ZERO 이다.

D3DRS_BLENDOPALPHA

렌더링 스테이트의 D3DRS_ALPHABLENDENABLE 가 TRUE 로 설정되어 있는 경우에, 개별의 알파 혼합에 적용하는 산술 연산의 선택에 사용하는 값.

유효한 값은,D3DBLENDOP 열거형으로 정의된다. 디폴트값은 D3DBLENDOP_ADD 이다.

D3DPMISCCAPS_BLENDOP 장치 능력이 지원되지 않은 경우는, D3DBLENDOP_ADD 가 실행된다. 「D3DPMISCCAPS 」를 참조할것.

D3DRS_FORCE_DWORD

이 열거형을 강제적으로 32 비트 사이즈에 컴파일 한다. 이 값은 사용되지 않았다.

주의

Direct3D 는, 애플리케이션에서의 편의를 고려해, (D3DRS_WRAP n 스테이트값의 1 개를 명시적으로 사용하는 대신에) 정수 D3DRENDERSTATE_WRAPBIAS 를 정의해, 텍스처 좌표 세트의 제로로부터 시작되는 정수값에 근거해, 텍스처 랩핑을 유효하게 하거나 무효로 하거나 한다. 다음과 같이 D3DRENDERSTATE_WRAPBIAS 값을 텍스처 좌표 세트의 제로로부터 시작되는 인덱스에 덧셈 해, 그 인덱스에 대응하는 D3DRS_WRAP n 값을 계산한다. //Enable U/V wrapping for textures that use the texture //coordinate set at the index within the dwIndex variable. HRESULT hr = pd3dDevice->SetRenderState( dwIndex + D3DRENDERSTATE_WRAPBIAS, D3DWRAPCOORD_0 | D3DWRAPCOORD_1); //If dwIndex is 3, the value that results from //the addition equals D3DRS_WRAP3 (131).

열거형의 정보


반응형
반응형

// 렌더링 타겟 보존 
m_pd3dDevice->GetRenderTarget(0, &pOldBackBuffer); 
m_pd3dDevice->GetDepthStencilSurface(&pOldZBuffer); 
m_pd3dDevice->GetViewport(&oldViewport); 

m_pd3dDevice->EndScene(); // 함수 바깥에서 실행된 BeginScene 해제 

// 렌더링 타겟 변경 
m_pd3dDevice->SetRenderTarget(0, m_pShadowSurf); 
m_pd3dDevice->SetDepthStencilSurface(m_pShadowTexZ); 
D3DVIEWPORT9 viewport = {0,0, MAP_SIZE,MAP_SIZE,0.0f,1.0f}; 
m_pd3dDevice->SetViewport(&viewport); 

행렬 설정 등등.... 

m_pd3dDevice->BeginScene(); 
메시를 그린다 
m_pd3dDevice->EndScene(); 

// 렌더링 타겟 복구 
m_pd3dDevice->SetRenderTarget(0, pOldBackBuffer); 
m_pd3dDevice->SetDepthStencilSurface(pOldZBuffer); 
m_pd3dDevice->SetViewport(&oldViewport); 
pOldBackBuffer->Release(); 
pOldZBuffer->Release();

반응형
반응형

DirectX 선그리기...

VertexBuffer 말고 다른 방법으로 선을 그리고 싶었다...
ID3DXLine 이란것이 있었따!!
D3DXVECTOR3 p[3];
p[0].x =0; p[0].y = 0; p[0].z = 0.0f;
p[1].x =0.1; p[1].y = 1; p[1].z = 0.0f;
p[2].x =2; p[2].y = 0; p[2].z = 0.0f;

p는 오브젝트의 월드공간에 있어야함

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

Device->BeginScene();
ID3DXLine *Line;
D3DXCreateLine(Device, &Line);
Line->SetWidth(width);
Line->SetAntialias(true);
Line->Begin();
Line->DrawTransform(p, 3, &(worldMat*viewMat*projMat), D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f));    //이때의 행렬은 전체월드행렬*뷰*프로젝션 행렬을 넘겨줘야함
Line->End();
Line->Release();
Device->EndScene();

반응형
반응형

http://cafe.naver.com/gameproj/5



* code sampler

 

Initialization
 

Demonstrates how to initialize Direct3D. This sample is by far the simplest of all Direct3D samples on this page. If you know nothing about Direct3D, you probably need to start here. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant C++ Keywords: Direct3DCreate9, GetAdapterDisplayMode, CheckDeviceFormat, GetDeviceCaps, CreateDevice, Clear, BeginScene, EndScene, Present, Release, D3D_SDK_VERSION, D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, D3DFMT_D16, D3DCREATE_HARDWARE_VERTEXPROCESSING, D3DSWAPEFFECT_DISCARD, D3DCLEAR_TARGET, D3DCLEAR_ZBUFFER, D3DCOLOR_COLORVALUE, BackBufferFormat, SwapEffect, Windowed, EnableAutoDepthStencil, and AutoDepthStencilFormat.

  •  Download (Last Updated: 05/27/05 - C++)

 

 

Full-Screen Initialization
 

This sample demonstrates how to probe the hardware for specific Display or Adaptor Modes and hardware support suitable for a full-screen application with Direct3D. Check out theOpenGL source code page for the OpenGL equivalent of this sample.

Relevant C++ Keywords: GetAdapterModeCount, EnumAdapterModes, CheckDeviceType, CheckDeviceFormat, GetDeviceCaps, D3DFMT_X8R8G8B8, D3DDISPLAYMODE, Width, Height, Format, RefreshRate, and D3DUSAGE_DEPTHSTENCIL.

 

  •  Download (Last Updated: 05/27/05 - C++)

 

 

View Ports
 

This sample demonstrates how to set multiple view ports using DirectX 9.0.

Relevant C++ Keywords: SetViewport, Clear, BeginScene, EndScene, Present, Y, X, Width, Height, MinZ, MaxZ, and D3DVIEWPORT9.

  •  Download (Last Updated: 06/02/05 - C++)

 

 

Multiple Devices
 

This sample demonstrates how to render to multiple windows using multiple devices under DirectX 9.0. You should note that this is not considered the most optimal way to manage two windows from one application. The preferred method is to create one Direct3D device and use CreateAdditionalSwapChain() to create additional front and back buffer pairs for rendering in multiple windows. This allows two windows to share resources like meshes and textures and keeps the driver from performing a costly context switch between multiple devices. The usage of CreateAdditionalSwapChain() is covered in the sample below.

Relevant Keywords: CreateDevice, Present, BeginScene, EndScene, and D3DPRESENT_PARAMETERS.

 

Swap Chains
 

This sample demonstrates how to render to multiple windows using swap chains under DirectX 9.0. This is far more efficient than creating multiple Direct3D devices, which is covered in the above sample.

Relevant Keywords: GetSwapChain, CreateAdditionalSwapChain, CreateDevice, GetBackBuffer, SetRenderTarget, Present, BeginScene, EndScene, D3DPRESENT_PARAMETERS, and LPDIRECT3DSWAPCHAIN9.

 Download 146 KB (Last Updated: 10/14/04)

Texture Mapping

Demonstrates basic texture mapping using a textured quad and a bitmap of some wooden floor tiles. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: D3DXCreateTextureFromFile, SetSamplerState, SetTexture, LPDIRECT3DTEXTURE9, D3DSAMP_MINFILTER, D3DSAMP_MAGFILTER, and D3DTEXF_LINEAR.

  •  Download 234.9 KB (Last Updated: 10/14/04)

Texture Filtering

Demonstrates how to filter out unwanted graphical artifacts from Direct3D textures. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: D3DXCreateTextureFromFile, SetSamplerState, SetTexture, LPDIRECT3DTEXTURE9, D3DSAMP_MINFILTER, D3DSAMP_MAGFILTER, D3DTEXF_NONE, D3DTEXF_POINT, D3DTEXF_LINEAR, D3DTEXF_ANISOTROPIC, D3DTEXF_FLATCUBIC, and D3DTEXF_GAUSSIANCUBIC,

  •  Download 201 KB (Last Updated: 10/14/04)

Texture Blending

Demonstrates how to alpha-blend Direct3D textures. The sample creates a textured cube as an example whose sides are alpha-blended with one another in such a way as to create a translucent effect. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetRenderState, D3DRS_ALPHABLENDENABLE, D3DRS_ZENABLE, D3DRS_SRCBLEND, D3DBLEND_SRCALPHA, D3DRS_DESTBLEND, D3DBLEND_ONE, D3DRS_CULLMODE, and D3DCULL_NONE.

  •  Download 219 KB (Last Updated: 10/14/04)

Texture Addressing

Demonstrates how texture addressing works under Direct3D by allowing the texture addressing mode to be changed at run-time with a textured quad whose texture coordinates range from 0.0 to 3.0. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetSamplerState, D3DSAMP_BORDERCOLOR, D3DSAMP_ADDRESSU, D3DSAMP_ADDRESSV, D3DSAMP_ADDRESSW, D3DTADDRESS_WRAP, D3DTADDRESS_CLAMP, D3DTADDRESS_MIRROR, D3DTADDRESS_BORDER, and D3DTADDRESS_MIRRORONCE.

  •  Download 198 KB (Last Updated: 10/14/04)

Texture Sub-loading

Demonstrates how texture sub-loading works under Direct3D by copying a smaller texture over the texel data of a larger texture. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: D3DXCreateTextureFromFile, D3DXLoadSurfaceFromSurface, LPDIRECT3DSURFACE9, LPDIRECT3DTEXTURE9, and D3DX_DEFAULT

  •  Download 190.6 KB (Last Updated: 10/14/04)

Texture Mip-mapping

This sample demonstrates how mip-mapping works under Direct3D by tiling a single textured quad across a 25x25 unit area. The original texture is simply white with a thin black border, but in a effort to show mip-mapping in action, several mip-map levels have been altered by replacing the auto generated mip-map texture for that level with a color-coded version. This causes mip-map filtering to produce rainbow colored bands which radiate across the surface as the eye point moves about. Check out the OpenGLsource code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetSamplerState, D3DXCreateTextureFromFile, D3DXLoadSurfaceFromSurface, LPDIRECT3DSURFACE9, LPDIRECT3DTEXTURE9, D3DX_DEFAULT, D3DSAMP_MINFILTER, D3DSAMP_MAGFILTER, D3DSAMP_MIPFILTER, D3DTEXF_NONE, D3DTEXF_POINT, D3DTEXF_LINEAR, and D3DTEXF_ANISOTROPIC.

  •  Download 197.5 KB (Last Updated: 10/14/04)

Multi-texture

This sample demonstrates how to perform multi-texturing under Direct3D by either modulating or adding two textures together in one rendering pass. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetTextureStageState, SetSamplerState, D3DTSS_TEXCOORDINDEX, D3DTSS_COLOROP, D3DTSS_COLORARG1, D3DTSS_COLORARG2, D3DTOP_MODULATE, D3DTA_TEXTURE, D3DTA_DIFFUSE, and D3DPT_TRIANGLESTRIP.

  •  Download 190.9 KB (Last Updated: 10/14/04)

Depth Bias

This sample demonstrates how to eliminate z-fighting when rendering polygons directly on top of other polygons  by using Direct3D's D3DRS_SLOPESCALEDEPTHBIAS and D3DRS_DEPTHBIAS render states.

Relevant Keywords: SetRenderState, D3DRS_SLOPESCALEDEPTHBIAS, and D3DRS_DEPTHBIAS.

  •  Download 198 KB (Last Updated: 10/14/04)

Fonts

This sample demonstrates how to render text to the screen using Direct3D's ID3DXFont class.

Relevant Keywords: GetDC, GetDeviceCaps, ReleaseDC, CreateFont, D3DXCreateFont, DeleteObject, SetRect, Begin, End, DrawText, RECT, DT_SINGLELINE, FW_DONTCARE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH, and FF_DONTCARE.

  •  Download 140 KB (Last Updated: 10/14/04)

View Matrix

Demonstrates how to manually modify the view matrix using mouse and keyboard input to create a game style motion control. This sample is very similar to the "First-Person-Shooter View Control" sample except this one uses no DirectInput. Check out theOpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetTransform, D3DXMatrixPerspectiveFovLH, D3DXMatrixRotationAxis, D3DXVec3TransformCoord, D3DXMatrixScaling, D3DXMatrixIdentity, D3DXVec3Normalize, D3DXVec3Dot,  D3DXVec3Cross, D3DXLoadMeshFromX, GetBufferPointer, DrawSubset, D3DXMATERIAL, D3DXMESH_SYSTEMMEM, D3DTS_VIEW, D3DTS_WORLD, D3DTS_PROJECTION, LPD3DXMESH, MatD3D, pTextureFilename, Ambient, and Diffuse.

  •  Download 280.7 KB (Last Updated: 10/14/04)

Lighting

This sample demonstrates the three basic types of lights that are available in Direct3D: directional, spot, and point. Check out theOpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetLight, SetRenderState, LightEnable, D3DXMatrixTranslation, D3DXMatrixRotationZ, D3DXToRadian, D3DXMatrixLookAtLH, D3DXMatrixInverse, D3DXCreateSphere, D3DXCreateCylinder, D3DRS_LIGHTING, D3DLIGHT_DIRECTIONAL, D3DLIGHT_SPOT, D3DLIGHT_POINT, D3DRS_AMBIENT, D3DLIGHT9, D3DMATERIAL9, Diffuse, Ambient, Type, Direction, Position, Theta, Phi, Falloff, Attenuation0, and Attenuation1.

  •  Download 150 KB (Last Updated: 10/14/04)

Materials

Demonstrates how to use materials with lighting to produce different surface effects. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetMaterial, SetRenderState, D3DLIGHT_DIRECTIONAL, SetLight, LightEnable, D3DMATERIAL9, D3DRS_DIFFUSEMATERIALSOURCE, D3DRS_SPECULARMATERIALSOURCE, D3DRS_AMBIENTMATERIALSOURCE, D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL, D3DLIGHT9, Diffuse, Ambient, Specular, Power, D3DRS_COLORVERTEX, D3DRS_AMBIENT, and D3DCOLOR_COLORVALUE.

  •  Download 183 KB (Last Updated: 10/14/04)

Lost Device Recovery

This sample demonstrates how to recover from a lost device. A device can become "lost" when an event, such as the loss of keyboard focus in a full-screen application, causes rendering to become impossible. The lost state is characterized by the silent failure of all rendering operations, which means that the rendering methods can return success codes even though the rendering operations fail. In this situation, the error code D3DERR_DEVICELOST is returned by IDirect3DDevice9::Present.

Relevant Keywords: Present, TestCooperativeLevel, D3DERR_DEVICELOST, D3DERR_DEVICENOTRESET, Reset, BackBufferWidth, BackBufferHeight, and Release.

  •  Download 341 KB (Last Updated: 10/14/04)

Resizing DirectX 9.0 Window

This sample demonstrates how to respond to the app's window getting resized by resizing the front and back buffers of the Direct3D device to match it. If you don't do this, Direct3D will be forced to perform a stretch blit when the window is enlarged and everything rendered will appearcourse and blocky. For example, if the initial window size and Direct3D device are set to 640x480 and you enlarge the window to be 1024x768, the Direct3D device will continue to render at 640x480 unless its front back buffers are resized accordingly.

Relevant Keywords: WM_SIZE, Reset, BackBufferWidth, BackBufferHeight, and Release.

  •  Download 341 KB (Last Updated: 10/14/04)

Point Sprites

This sample demonstrates how to use point sprites with Direct3D. Point sprites are hardware-accelerated billboards, which are capable of being textured. Point sprites are ideal for creating high-performance particle systems because you only have to send a single vertex point or point sprite for each particle instead of four vertices for a regular billboarded quad. Point sprites also do all the math involved in view aligning the final quad on the GPU instead of the CPU. See the Particle System sample below for a more complex example of their usage. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: SetRenderState, D3DUSAGE_DYNAMIC, D3DUSAGE_POINTS, D3DUSAGE_WRITEONLY, D3DFVFCAPS_PSIZE, D3DRS_POINTSPRITEENABLE, D3DRS_POINTSIZE, D3DRS_POINTSIZE_MIN, D3DRS_POINTSCALE_A, D3DRS_POINTSCALE_B, D3DRS_POINTSCALE_C, D3DLOCK_DISCARD, D3DPT_POINTLIST, D3DRS_ALPHABLENDENABLE, D3DBLEND_ONE, D3DRS_ZWRITEENABLE, D3DLOCK_DISCARD, and FVFCaps.

 Note: Requires a video card that supports Direct3D Point Sprites.

  •  Download 193.4 KB (Last Updated: 10/14/04)

Particle System (Using Point Sprites)

Adding a particle system to your game engine has become all the rage, but where do you start? Here of course! This sample demonstrates how to create a particle system class which uses Direct3D's hardware accelerated point sprites. To learn more about point sprites, check out the Point Sprites sample above. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

 Note: Requires a video card that supports Direct3D Point Sprites.

  •  Download 231.5 KB (Last Updated: 10/14/04)

Off-screen Rendering

This code sample demonstrate how to create dynamic textures through the use of an off-screen rendering surface under Direct3D. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: D3DXCreateRenderToSurface, D3DXMatrixRotationYawPitchRoll, LPD3DXRENDERTOSURFACE, LPDIRECT3DTEXTURE9, and LPDIRECT3DSURFACE9.

  •  Download 193.5 KB (Last Updated: 10/14/04)

Occlusion Query

This sample demonstrates how to use Direct3D new occlusion query feature to find out how many pixels of an object are actually visible. The sample is basically a simplified port of the nVIDIA's OpenGL sample, which covers the same subject. Check out theOpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: CreateQuery, GetData, D3DXCreateSphere, D3DXCreateBox, CloneMeshFVF, GetVertexBuffer, GetNumVertices, D3DQUERYTYPE_OCCLUSION, Issue, D3DISSUE_BEGIN, D3DISSUE_END, and LPDIRECT3DQUERY9.

 

Primitive Types

This sample demonstrates how to use the 6 primitive types available under Direct3D: point list, line list, line strip, triangle list, triangle strip, and triangle fan.

Relevant Keywords: CreateVertexBuffer, Lock, Unlock, SetStreamSource, SetTexture, SetFVF, DrawPrimitive, D3DPT_POINTLIST, D3DPT_LINELIST, D3DPT_LINESTRIP, D3DPT_TRIANGLELIST, D3DPT_TRIANGLESTRIP, D3DPT_TRIANGLEFAN, LPDIRECT3DVERTEXBUFFER9, LPDIRECT3DTEXTURE9, and D3DPOOL_DEFAULT.

  •  Download 84.8 KB (Last Updated: 10/14/04)

Vertex Data (Vertex Buffers)

Demonstrates how to use Vertex Buffers for the storage of model data. The sample creates a textured cube as an example. Check out the OpenGL source code page for a Vertex Array sample which is OpenGL's equivalent of Direct3D's Vertex Buffers.

Relevant Keywords: CreateVertexBuffer, Lock, Unlock, SetStreamSource, SetTexture, SetFVF, DrawPrimitive, LPDIRECT3DVERTEXBUFFER9, LPDIRECT3DTEXTURE9, D3DPT_TRIANGLESTRIP, and D3DPOOL_DEFAULT.

  •  Download 189.8 KB (Last Updated: 10/14/04)

Multiple Vertex Buffers

This sample demonstrates how to create 3D geometry with Direct3D by loading vertex data into multiple Vertex Buffers. Check out theOpenGL source code page for the OpenGL equivalent of this sample, which uses multiple Vertex Arrays.

Relevant Keywords: CreateVertexBuffer, Lock, Unlock, SetStreamSource, SetTexture, SetFVF, DrawPrimitive, CreateVertexDeclaration, SetVertexDeclaration, SetStreamSource, D3DDECL_END, LPDIRECT3DVERTEXDECLARATION9, D3DVERTEXELEMENT9, D3DDECLTYPE_FLOAT3, D3DDECLTYPE_D3DCOLOR, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, D3DDECLUSAGE_COLOR, D3DDECLUSAGE_TEXCOORD LPDIRECT3DVERTEXBUFFER9, LPDIRECT3DTEXTURE9, D3DPT_TRIANGLESTRIP, and D3DPOOL_DEFAULT.

  •  Download 192.8 KB (Last Updated: 10/14/04)

Indexed Geometry

This sample demonstrates how to optimize performance by using indexed geometry. As a demonstration, the sample reduces the vertex count of a simple cube from 24 to 8 by redefining the cube’s geometry using an indices array. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: CreateVertexBuffer, CreateVertexBuffer, Lock, Unlock, DrawIndexedPrimitive, DrawPrimitive, D3DPT_TRIANGLESTRIP, SetStreamSource, SetIndices, SetFVF, D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, , and D3DPOOL_DEFAULT.

  •  Download 92 KB (Last Updated: 10/14/04)

Transforms

Demonstrates how to use concatenated translation, rotation, and scaling matrices to create a simulated solar system. And as a small bonus, the sample also demonstrates how to optimize Direct3D applications using a matrix stack to prevent continuous changes to the view matrix, which can kill your apps draw time.

On an unrelated side-note, the sample also shows how to clone a mesh so you can add additional properties to its FVF code or vertex layout. The sample uses D3DXCreateSphere to create test spheres, which originally have no color. I then clone the mesh and add colors to them for demo purposes.

Relevant Keywords: SetTransform, D3DXMatrixTranslation, D3DXMatrixRotationY, D3DXMatrixScaling, D3DXCreateSphere, CloneMeshFVF, GetVertexBuffer, GetNumVertices, D3DXCreateMatrixStack, LoadIdentity, LoadMatrix, Push, Pop, MultMatrixLocal, LPD3DXMATRIXSTACK, and LPD3DXMESH.

  •  Download 203 KB (Last Updated: 10/14/04)

Emboss Bump Mapping

These samples demonstrate how to perform one-pass and two-pass emboss bump mapping with Direct3D. I've also included code, which demonstrates how to calculate tangent and binormal vectors on a per-vertex basis. These special vectors define the texture space for each vertex, which allows for accurate texture coordinate shifting during the bump mapping process. Check out theOpenGL source code page for the OpenGL equivalent of these samples.

Relevant Keywords: SetTextureStageState, SetRenderState, SetTexture, D3DXVec3Dot, D3DXVec3Normalize, D3DXMatrixInverse, GetTransform, D3DXCreateSphere, D3DTSS_TEXCOORDINDEX, D3DTSS_COLOROP, D3DTSS_COLORARG1, D3DTSS_COLORARG2, D3DTSS_ALPHAOP, D3DTSS_ALPHAARG1, D3DTSS_ALPHAARG2, D3DTOP_MODULATE, D3DTA_TEXTURE, D3DTA_DIFFUSE, D3DTOP_SELECTARG1, D3DTA_CURRENT, D3DTOP_ADDSIGNED, D3DTA_COMPLEMENT, D3DTOP_MODULATE2X, D3DTA_ALPHAREPLICATE, D3DTOP_DISABLE, and D3DRS_ALPHABLENDENABLE.

 Note: If you have an older video card and the one-pass sample fails to work, try the "One-pass Fake Emboss Bump Mapping" code, which I left in the sample.

Shadow Volume

This code sample demonstrates how to create dynamic shadows with Direct3D using a stencil shadow volume. The sample is basically a simplified re-write of the ShadowVolume sample that ships with the DirectX 9 SDK.

Relevant Keywords: GetBackBuffer, SetRenderState, D3DXLoadMeshFromX, GetDeviceCaps, Lock, Unlock,  D3DSTENCILCAPS_TWOSIDED, D3DBACKBUFFER_TYPE_MONO, D3DRS_STENCILENABLE, D3DRS_SHADEMODE, D3DRS_STENCILENABLE, D3DRS_STENCILFUNC, D3DRS_STENCILZFAIL, D3DRS_STENCILFAIL, D3DRS_STENCILREF, D3DRS_STENCILMASK, D3DRS_STENCILWRITEMASK, D3DCMP_LESSEQUAL, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP, D3DRS_ZWRITEENABLE, D3DRS_ALPHABLENDENABLE, D3DRS_SRCBLEND, D3DRS_DESTBLEND, D3DBLEND_ZERO, D3DBLEND_ONE, D3DSTENCILOP_KEEP, D3DCMP_ALWAYS, D3DSHADE_FLAT, D3DSTENCILOP_DECR, D3DRS_CULLMODE, D3DCULL_NONE, D3DCULL_CCW, D3DSHADE_GOURAUD, D3DRS_FILLMODE, D3DFILL_WIREFRAME, D3DFILL_SOLID, and StencilCaps.

  •  Download 287.9 KB (Last Updated: 10/14/04)
  •  Learn More 336 KB
  •  Learn More (Gamasutra.com - Real-Time Shadow Casting Using Shadow Volumes)
  •  Learn More (GameDev.net - The Theory of Stencil Shadow Volumes)

Creating 2D Sprites with D3DXSprite

This sample demonstrates how to create a animated 2D sprite using D3DXSprite which is hardware accelerated and fully compatible with 3D generated content.

  •  Download 229 KB (Last Updated: 10/14/04)

Simple Effect Using .fx Files

This sample demonstrates how to write and use Effect files (.fx) under DirectX 8.1. The sample Effect is very straightforward. It defines a technique called "TwoPassTextureBlend", which has two separate rendering passes, called "Pass0" and "Pass1". The two passes are then used to basically blend two textures together through the simple addition of the texel data.

Relevant Keywords: D3DXCreateEffectFromFile, GetBufferPointer, SetTexture, SetTechnique, Begin, End, texture, technique, pass, AlphaBlendEnable, Texture, ColorOp, ColorArg1, SelectArg1, Disable, and LPD3DXEFFECT.

  •  Download 445.8 KB (Last Updated: 10/14/04)

Simple Vertex & Pixel Shader (HLSL/Fx Effect File)

This code sample demonstrates how to write simple vertex and pixel shaders using Direct3D's new High-Level Shading Language. The two shaders reside within a Direct3D Fx Effect File and have matching inputs and outputs, which allow them to be used simultaneously on the same piece of geometry.

Relevant Keywords: D3DXCreateEffectFromFile, SetTechnique, SetMatrix, SetTexture, Begin, End, float4x4, texture, sampler, technique, pass, LPD3DXEFFECT, and LPD3DXBUFFER.

  •  Download 445.4 KB (Last Updated: 10/14/04)

Simple Vertex Shader (vs.2.0)

Demonstrates how to write an assembly-level vertex shader using the vs2.0 instruction set defined in DirectX 9.0.

Relevant Keywords: CreateVertexDeclaration, D3DXAssembleShaderFromFile, CreateVertexShader, LPDIRECT3DVERTEXDECLARATION9, LPDIRECT3DVERTEXSHADER9, D3DVERTEXELEMENT9, ID3DXBuffer, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_COLOR, D3DDECLUSAGE_POSITION, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECL_END, vs.2.0, dcl_position, dcl_color, m4x4, oPos, oD0, and mov.

  •  Download 338 KB (Last Updated: 10/14/04)

Simple Vertex Shader (Cg)

Demonstrates how to write a simple vertex shader, or vertex program using Cg. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: CGcontext, CGprogram, CGparameter, cgCreateContext, cgD3D9GetLatestVertexProfile, cgCreateProgramFromFile, cgD3D9ValidateVertexDeclaration, cgD3D9LoadProgram, cgGetNamedParameter, cgGetParameterType, cgD3D9TypeToSize, cgD3D9SetDevice, cgDestroyProgram, cgDestroyContext, cgD3D9SetUniformMatrix, cgD3D9SetUniform, cgD3D9BindProgram, CreateVertexDeclaration, LPDIRECT3DVERTEXDECLARATION9, LPDIRECT3DVERTEXDECLARATION9, POSITION, COLOR0, uniform, float4x4, float4, mul, and return.

  •  Download 69.3 KB (Last Updated: 10/14/04)

Simple Vertex & Pixel Shader (Cg)

Demonstrates how to write both a simple vertex and pixel shader using Cg. The two shaders have matching connectors and can be used simultaneously on the same piece of geometry. The shaders in this sample don't really do anything useful or neat, it's meant to be used as a framework or starting place for experimenting with shaders. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: cgD3D9GetLatestPixelProfile, cgD3D9GetOptimalOptions, cgD3D9SetTextureWrapMode, cgD3D9SetSamplerState, cgD3D9BindProgram, D3DXMatrixTranspose, D3DXMatrixRotationYawPitchRoll, D3DVERTEXELEMENT9, D3DDECLTYPE_FLOAT3, D3DDECLUSAGE_POSITION, D3DDECLTYPE_D3DCOLOR, D3DDECLUSAGE_COLOR, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, D3DSAMP_ADDRESSUD3DSAMP_ADDRESSV, D3DTADDRESS_WRAP, D3DTEXF_POINT, D3DTEXF_NONE, D3DSAMP_MINFILTER, D3DSAMP_MAGFILTER, D3DSAMP_MIPFILTER, float2, float3, float4, uniform, float4x4, sampler2D, and tex2D.

  •  Download 194 KB (Last Updated: 10/14/04)

Lighting Shader (Cg)

Demonstrates how to write a vertex shader using Cg, which calculates simple diffuse lighting for a single light source. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: cgD3D9SetUniformMatrix, cgD3D9SetUniform, SetLight, SetRenderState, LightEnable, SetMaterial, D3DLIGHT9, D3DMATERIAL9, D3DRS_LIGHTING, LPDIRECT3DVERTEXDECLARATION9, POSITION, NORMAL, COLOR0, float4, float4x4, uniform, mul, normalize, dot, and pow.

  •  Download 87.2 KB (Last Updated: 10/14/04)

Anisotropic Lighting Shader (Cg)

Demonstrates how to write a vertex shader using Cg, which calculates Anisotropic Lighting for a single light source. The shader uses a texture as a look-up table for the correct Anisotropic Lighting values by storing the pre-calculated diffuse values in the texture's RGB components and specular values in its alpha component. This style of lighting is very useful for rendering surfaces like brushed steel where the surface is composed of micro facets or microscopic scratches that tend to lay parallel or run in the same direction. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: D3DXLoadMeshFromX, GetVertexBuffer, GetIndexBuffer, CloneMeshFVF, Optimize, GetAttributeTable, LPDIRECT3DVERTEXDECLARATION9, LPDIRECT3DINDEXBUFFER9, D3DXATTRIBUTERANGE, D3DXMESH_SYSTEMMEM, D3DXMESHOPT_ATTRSORT, D3DXMESH_WRITEONLY, D3DSAMP_ADDRESSU, D3DTADDRESS_MIRROR, D3DTOP_MODULATE4X, D3DTA_ALPHAREPLICATE, D3DTSS_COLOROP, D3DTSS_COLORARG1, D3DTSS_COLORARG2, D3DTA_TEXTURE, POSITION, NORMAL, TEXCOORD0, float3x3, float3x4, normalize, mul, and max.

Vertex Displacement or Mesh Deformation Shader (Cg)

10.0pt; color: black"> Demonstrates how to performs vertex displacement on a simple mesh to create a flag waving animation. 10.0pt; color: black">Check out the OpenGL source code 10.0pt; color: black">page for the OpenGL equivalent of this sample.

Relevant Keywords: CGcontext, CGprogram, CGparameter, cgCreateContext, cgD3D9GetLatestVertexProfile, cgCreateProgramFromFile, cgD3D9ValidateVertexDeclaration, cgD3D9LoadProgram, cgGetNamedParameter, cgGetParameterType, cgD3D9TypeToSize, cgD3D9SetDevice, cgDestroyProgram, cgDestroyContext, cgD3D9SetUniformMatrix, cgD3D9SetUniform, cgD3D9BindProgram, CreateVertexDeclaration, SetRenderState, D3DRS_FILLMODE, D3DFILL_WIREFRAME, D3DFILL_SOLID, LPDIRECT3DVERTEXDECLARATION9, LPDIRECT3DVERTEXDECLARATION9, POSITION, COLOR0, uniform, float4x4, float4, mul, sin, and return.

  •  Download 198 KB (Last Updated: 10/14/04 )

Solid Node BSP Tree Compiler

One method of speeding up a game engine is to use a BSP-Tree (Binary-Space Partitioning Tree) to subdivide and sort your game's world geometry.

This is done by dividing up, sorting, and storing polys in a BSP Tree in a such as way as to denote their relationship to one another (i.e. being in front of or in back of another poly). Once the BSP tree is compiled or built, the engine can quickly decide whether or not it should render certain polys based on the view’s current location within the world.

For example, the BSP compiler in this sample demonstrates how early game programmers, who didn't have hardware accelerated z-buffers, used a simple solid-node style BSP tree to sort their scene polys into a back-to-front order for proper rendering. The sample also demonstrates how a BSP Tree can be used for collision detection by identifying whether or not a unobstructed line-of sight can be established between two 3D points.

Unfortunately, the code doesn't go into a lot of BSP Tree theory or teach the basics, so if you're new to the concept of a BSP Tree, check out this cool little Java Applet for a real-time demonstration of how they work.

This sample is based on one of the BSP demos that came with the "Advanced 3D BSP, PVS and CSG Techniques" course offered at GameInstitute.com. If you're truly interested in learning about BSP trees and how they're used in games, this course is the best by far and I highly recommend it.

Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: CreateDevice, SetSamplerState, SetDataFormat, GUID_SysMouse, SetCooperativeLevel, Acquire, Unacquire, GetDeviceState, DrawIndexedPrimitiveUP, D3DXVec3Dot, DISCL_NONEXCLUSIVE, DISCL_FOREGROUND, LPDIRECTINPUT8, LPDIRECTINPUTDEVICE8, D3DXVECTOR3, DIERR_INPUTLOST, DIMOUSESTATE2, D3DSAMP_MIPMAPLODBIAS, D3DSAMP_MAGFILTER, D3DSAMP_MINFILTER, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR, D3DFMT_INDEX16 and DIRECTINPUT_VERSION.

2D Demo Game of a Side-Scrolling Shooter

Re-live such classic side-scrolling shooters as Gradius and R-Type by writing your own. Of course, this sample is a far cry from a fully featured side-scroller, but it will definitely put you on the right track. Check out the DirectX 8.1 source code page for the DirectX 8.1 code equivalent of this sample.

  •  Download 378 KB (Last Updated: 05/11/04)

How to use the Tokamak SDK to Create a Rope or Chain using Ball-Joints

This sample demonstrates how to use the Tokamak Physics SDK to create a chain or rope like object by using small collision cubes joined by ball-joints. For demonstration purposes, the chain is dropped onto a platform, which doesn’t quite catch all of it. This allows the chain to hang off and swing about. For fun, you can use the F1 key to lift up on the chain's last segment by applying some velocity to it. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: neSimulator, neRigidBody, neAnimatedBody, neSimulatorSizeInfo, neBoxInertiaTensor,  neJoint, neGeometry, CreateSimulator, CreateRigidBody, AddGeometry, SetBoxSize, CollideConnected, UpdateBoundingInfo, SetInertiaTensor, SetMass, SetJointFrameWorld, SetType, SetEpsilon, SetIteration, Enable, and GetTransform.

  •  Download 161 KB (Last Updated: 10/14/04)

How to use the Tokamak SDK to Create a Stack of Blocks

This sample demonstrates how to use the Tokamak Physics SDK to create a stack of blocks which can be knocked over. For demonstration purposes, you can use the F1 key to lift up and drop the bottom block, which will obviously disturb the stack. You can also use the F2 key to tilt the blue platform and dump the blocks over the side. Check out the OpenGL source code page for the OpenGL equivalent of this sample.

Relevant Keywords: neSimulator, neRigidBody, neAnimatedBody, neSimulatorSizeInfo, neBoxInertiaTensor,  neJoint, neGeometry, CreateSimulator, CreateRigidBody, AddGeometry, SetBoxSize, UpdateBoundingInfo, SetInertiaTensor, SetMass, Enable, SetRotation and GetTransform.

  •  Download 161 KB (Last Updated: 10/14/04)

How to use Tokamak's Different Geometry Types or Collision Primitives

This sample demonstrates how to use the box, sphere, and cylinder geometry types of the Tokamak Physics SDK. The sample is basically a variation of the stacking sample above.

Relevant Keywords: neRigidBody, neAnimatedBody, SetBoxSize, neBoxInertiaTensor, SetCylinder, neCylinderInertiaTensor, SetSphereDiameter, and neSphereInertiaTensor.

  •  Download 226 KB (Last Updated: 10/14/04)

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

렌더타겟,스텐실  (0) 2012.11.02
DirectX 선그리기  (2) 2012.11.02
D3DPRESENT_INTERVAL_IMMEDIATE  (0) 2012.11.02
ID3DXSprite 이미지 출력 , 빌보딩  (0) 2012.11.02
OpenGL 좌표계에서 D3D좌표계로  (0) 2012.11.02
반응형

LightPls님이 답변해 주셨습니다.

//다이렉트 3D의 디바이스를 생성하기 위해D3DPRESENT_PARAMETERS 구조체를 사용한다. 
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof( d3dpp ) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
// Directx에서는 디폴터로 최대 초당 프레임 수가 모니터 주파수와 동일하게 나오게끔 되어있다
// 이것을 해제 하기 위해서는 아래의 옵션을 추가해 주어야 한다.

d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

// 디바이스를 생성한다.
m_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
        hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, 
        &d3dpp, &m_pd3dDevice );

DX 초기화 부분에서 디바이스 생성부분을 이렇게 수정하시면 해결될겁니다.. ^^*


반응형
반응형

1 ID3DXSprite 란? #

d3d 내에서 2D를 표현하기 위한 인터페이스


2 ID3DXSprite 의 사용법 #

Begin스프라이트를 드로잉(Drawing) 할 수 있도록(듯이) 장치를 준비한다.
Draw스크린 공간에 단순한 스프라이트를 드로잉(Drawing) 한다.
DrawTransform지정한 행렬에 의해 변환 한 스프라이트를 드로잉(Drawing)하기 위한 구조를 제공한다.
EndID3DXSprite::Begin 가 불려 간 시점의 장치 스테이트를 복원한다.
GetDevice스프라이트 개체에 관련지을 수 있는 Direct3D 장치를 얻어온다.
OnLostDevice비디오 메모리 리소스에의 참조를 모두 릴리즈 해, 모든 스테이트 블록을 삭제한다.
OnResetDevice장치가 리셋 된 후에 호출할 필요가 있다.|

위의 표는 다이렉트X 헬프에 있는 내용이다. 사용법을 간단히 말하면 IDirect3DDevice9::BeginScene 과 IDirect3DDevice9::EndScene 사이에 ID3DXSprite::Begin 과 ID3DXSprite::End 를 호출하고 그 사이에 그리면 된다.


           IDirect3DDevice9::BeginScene
          
           ID3DXSprite::Begin
          
           << 여기다가 그리는걸 호출 >>>
          
           ID3DXSprite::End
          
           IDirect3DDevice9::EndScene
          


코드가 대충 이런 형태가 된다. 그릴때는 Draw 메소드를 호출해서 사용하는데


           HRESULT Draw(LPDIRECT3DTEXTURE9 pSrcTexture,
          
           CONST RECT *pSrcRect,
          
           CONST D3DXVECTOR2 *pScaling,
          
           CONST D3DXVECTOR2 *pRotationCenter,
          
           FLOAT Rotation,
          
           CONST D3DVECTOR2 *pTranslation,
          
           D3DCOLOR Color
          
           );
          


드로우 함수의 인자들 설명을 하자면
  • 첫번째 인자는 스프라이트에 사용할 텍스쳐이다. 스프라이트는 2D 게임프로그래밍을 해본사람이라면 느낌일 팍 올테니...
  • 두번째 RECT 구조체의 인자는 덱스쳐중에 어느 부분을 사용할것이가를 의미한다.
  • 세번째 D3DXVECTOR2 는 스케일링 인자라고하는데 x, y가 각각 가로 세로로 얼마나 늘려서 아니면 줄여서 사용할 것인지를 나타낸다. 뭐 기본값은 1.0f , 1.0f 다. 두배로 늘릴려면 2.0f, 2.0f 로 쓸수 있다. 음 RECT로 한픽셀 범위만 잡은뒤 가로 세로로 늘려서 원하는 길이의 선분을 얻을수도 있다. 뭐 대충 그런식...
  • 네번째 D3DXVECTOR2 는 회전중심이라고 하는데 아직 사용해보지는 않아서 모르겠지만 다섯번째 인자로 회전을 할때 어디를 중심으로 할것인가를 나타낸다. 기본값은 0.0f, 0.0f 이다.
  • 다섯번째 FLOAT 는 회전값인데.. 1.0f 를 넣어주니 90도가 회전했다. 음 정확한건 모르겠다.
  • 여섯번째 D3DCOLOR 은 값에 의해 컬러 채널과 알파 채널이 곱셈된다 라고 써있다.. 그냥 0xFFFFFFFF 를 넣어주면 원래 이미지 그래도 찍힌다. 흐음 마스킹값을 넣어주는 건가? 
인자를 설명하면 대충이렇다.(아아 정말 대충이다.) 그런데 이 스프라이트객체를 사용할때는 꼭 2의 X승 크기의 이미지를 사용해야 한다. 안그러면 RECT 구조체로 범위를 지정할때 엉망징창이 된다. 어떤 사람은 메모리도 센다고 하더라...


그리고 당연한 소리같지만 스프라이트 역시 순서에 따러 덥힌다. 즉 스프라이트를 찍고 오브젝트를 렌더링 하면 오브젝트에 가려 스프라이트가 안보일수고 있다는 것이다. 스프라이트도 D3D에서는 프리미티브로 처리할줄 알았는데... 조금 다른가보다.

 

// 스프라이트 객체 생성
 D3DXCreateSprite( g_pd3dDevice, &pSprite );

 // 텍스쳐 생성
 D3DXCreateTextureFromFile( g_pd3dDevice, "..\\res\\google.bmp", &m_Bground );

 

 RECT rext = { 0, 0, 16, 17 };
  pSprite->Begin( D3DXSPRITE_ALPHABLEND | D3DXSPRITE_SORT_TEXTURE );
  pSprite->Draw( m_Bground, &rext, NULL, &D3DXVECTOR3( g_MousePoint->x, g_MousePoint->y, 0 ), 0xffffffff );
  pSprite->End();

 
======================================================================================================

[Direct3D] ID3DXSprite로 BillBoard 사용하기

몇년전 DX가지고 이런말 하는 것도 우습지만, DX가 버전업하면서 
단순한 스크린평면에 텍스쳐를 뿌리는 것뿐이었던 ID3DXSprite가 여러가지 기능을 탑재하게 되었습니다. 

그중 빌보드를 구현할 수 있다는 내용도 포함되어 있죠. 
예전에는 기능이 있다는 것만 알고 넘어갔는데
얼마 전 수업에서 언급되었길래 한번 사용법을 찾아봤습니다... 


당연히 3D상에서 빌보드효과를 위해선 월드좌표상에서 텍스쳐를 뿌려야겠죠...
(g_SP가 ID3DXSprite 객체입니다. D3DXCreateSprite로 생성합니다.)

g_SP->Begin(D3DXSPRITE_BILLBOARD | D3DXSPRITE_OBJECTSPACE);

그리고 출력을 합니다. 

g_SP->Draw(g_pTxFloor, NULL, NULL, NULL, 0xffffffff);


당연히 제대로 출력될 리가 없죠...
BillBoard는 항상 카메라를 향하며 회전하므로, 그에 대한 정보를 넣어줘야 하니깐요. 
카메라 정보를 전달해 주는 것은 SetWorldViewLH메소드가 맡고 있습니다. 

g_SP->SetWorldViewLH(NULL, &mxView);


문제는 SetWorldViewLH의 호출 위치입니다!!!
이 함수는 Begin과 End내에서 호출하면 실패하게 됩니다. 
반드시 Begin 앞에서 호출해줘야 합니다!!!

이것때문에 좀 해맸네요...
빌어먹을... MSDN에도 명시되어 있지 않습니다... 



몇가지 유추한 것들을 적자면

SetWorldView의 WorldMatrix는 BillBoard에선 사용하지 않는 듯 싶습니다. 값변화가 적용되지 않습니다. 
대신 위치를 지정할땐, Draw의 Position Vector로 입력해주면 됩니다. 
또한 빌보드의 회전축은 기본적으로 이미지의 좌하단입니다. (Draw시 NULL 입력할때)

정상적인 빌보드로 사용할려면 이미지의 중심을 센터로 잡아줘야 하는데,
이때의 좌표값은 텍스쳐의 물리적 위치입니다. (일반적으로 1.0으로 맵핑되는 방식이 아닙니다.)
예를 들어 512x512이미지라면 256, 256를 넣어줘야 중심으로 지정됩니다. 

그리고 월드스페이스상의 메쉬의 크기는 별도의 지정하는 게 안보이고
상대적으로 매우 커지는 것으로 봐선, 이미지의 크기만큼 메쉬를 생성하는게 아닐까 싶네요. 
적당히 스케일해줘야겠죠... 자세한건 실험해보거나 문서를 찾아보면 되겠죠... 


써 본 감상으로는.... 
그냥 빌보드 오브젝트 따로 만들어서 쓰고 말겠습니다.... 
만드는 것도 간단하고, 다른 메쉬들과 호환성도 유지할 수 있고 말이죠... 커스텀도 가능하고...

외국쪽에서도 그렇고, 자료 정말 없네요.....
하긴 그다지 필요 없어보이긴 하죠 --;;;
 
 
스프라이트로 글자 출력도 가능하다

반응형
반응형

출처 : gamza.net

** OpenGL 좌표계에서 D3D좌표계로... **
copyrightⓒ 김성수 [2002년 04월 30일]

D3D는 왼손좌표계, OpenGL은 오른손좌표계를 사용합니다.


D3D좌표계(좌)와 OpenGL좌표계(우)

두 좌표계의 변환은 보통 y축과 z축을 맞바꾸는방법이 사용됩니다.
y축과 z축을 교환하는것은 일반적인 모델링툴에서 윗쪽벡터를..
왼손좌표계 -> y 축 , 오른손좌표계 -> z 축
으로 잡기 때문입니다. 때문에 멀쩡히 서있던 캐릭터를 눕혀놓지 않으려면 y축과 z축을 바꿔줘야 하죠.

1. 행렬변환
사용하는 좌표계와 다른 (회전/이동/확대축소)행렬을 사용해야 할경우, 사용할 행렬의 앞뒤에 다음행렬을 곱해서 자신이 사용하는 좌표계로 변환할수 있습니다.

[ 1 0 0 0 ]
[ 0 0 1 0 ]
[ 0 1 0 0 ]
[ 0 0 0 1 ]
좌표계 변환행렬
(y축과 z축을 맞바꾼다)

예> D3D행렬 = 좌표계변환 행렬 * OpenGL 행렬 * 좌표계변환행렬
이론적으로 이렇다는 말이고 실제는 그냥 행렬의 2행 3행을 맞바꾼다음, 2열 3열을 맞바꿔버리는 방법을 쓰죠.

2. 데이터 변환
데이터와 어플리케이션의 좌표계가 다를 경우 원본데이터를 읽어올때 데이터에 좌표계 변환행렬을 곱해버립니다.
( 이것두 말로하자면 그렇다는 얘기고, 행렬을 곱하구 자시구 할것두 없이 y와 z를 맞바꾸기만 하면됩니다. )

잠깐[1]
여기서 주의할것은 오른손좌표계의 데이터를 왼손좌표계에서 그대로 출력하면 폴리곤이 뒤집힌다는 것입니다. 이때 좌표계 변환 행렬이 이것을원상복귀 시켜주게되죠.
그런데...보통 오른손 좌표계에서는 폴리곤의 앞면을 반시계방향으로 정의하고, 왼손좌표계에선 시계방향을 앞면으로 정의하기때문에...
결국은....일반적으로는 폴리곤을 읽어올때 뒤집어서 읽어와야 합니다.

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

D3DPRESENT_INTERVAL_IMMEDIATE  (0) 2012.11.02
ID3DXSprite 이미지 출력 , 빌보딩  (0) 2012.11.02
D3DX 직교투영  (0) 2012.11.02
3ds lib & 3ds SDK Toolkit  (0) 2012.11.02
픽킹 ppt  (0) 2012.11.02
반응형

D3DXMatrixOrthoLH 직교 투영  ┃Study Room 

2007/11/09 09:08

복사http://deathknight2.blog.me/30024043545


첨부파일(1)

직교투영을 하면 원근감이 없어진다. Z이 없어지는 것이다.

 

D3DXMAtrixOrthoLH( &matproj, 800.0f, 600.0f, 1.0f, 500.0f);

의 인자는 2번째는 가로 싸이즈 3번쨰는 세로 싸이즈 4번째는 클리핑할 시작영역 5번째는 클리핑할 끝영역이다.

 

직교투영을 하면 화면의 가운데가 0, 0 인 좌표가 된다. 화면의 왼쪽 끝이 -400.f 일 것이고 화면의 오른쪽 끝이

 

400.0f 이다

 

아무튼 직교투영은 인터페이스를 만들때 유용하게 쓰인다.

예를 들어 3D물체를 습득하여 인터페이스창에 넣고 싶을때 그것을 직교투영 X,Y 좌표 값에 위치 시켜주면된

다는것이다.

 

직교투영도 3D 공간상이기때문에 회전 이동이 가능하다. 월드 셋팅이 된다는 것이다.

월드셋팅되기때문에 카메라이동시 위치가 틀리면 안보인다는 것이다. 그래서 인터페이스를 만들때 이점을

생각해야한다.

 

카메라 소스에 SetProjection에 D3DXMAtrixPerpectiveFovLH를 주석 잡고 직교투영을 한 결과다.

주석풀고 서로를 비교해보면 될것이다.

 

버텍스 크기가 월래 작은거라서 직교투영하면 스케일해줘야한다.

 

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

ID3DXSprite 이미지 출력 , 빌보딩  (0) 2012.11.02
OpenGL 좌표계에서 D3D좌표계로  (0) 2012.11.02
3ds lib & 3ds SDK Toolkit  (0) 2012.11.02
픽킹 ppt  (0) 2012.11.02
BackBuffer 와 스왑체인저  (0) 2012.11.02
반응형

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

OpenGL 좌표계에서 D3D좌표계로  (0) 2012.11.02
D3DX 직교투영  (0) 2012.11.02
픽킹 ppt  (0) 2012.11.02
BackBuffer 와 스왑체인저  (0) 2012.11.02
쿼드뷰 swapchain class 정리  (0) 2012.11.02
반응형

http://vmlab.suwon.ac.kr/mwlee/data2/file/game15.ppt#256,1,제 15 장 픽킹

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

D3DX 직교투영  (0) 2012.11.02
3ds lib & 3ds SDK Toolkit  (0) 2012.11.02
BackBuffer 와 스왑체인저  (0) 2012.11.02
쿼드뷰 swapchain class 정리  (0) 2012.11.02
정점 압축[Vertex Component Packing 처리]  (0) 2012.11.02
반응형

화면에 보여줄 내용을 백버퍼 대신 사용자가 지정한 서피스(Surface)에 그리게 하는 기능이다.

IDirect3DDevice9 의 함수중에 쓸것은..

CreateRenderTarget
SetRenderTarget
GetRenderTarget

CreateRenderTarget으로 surface를 만든다.
GetRenderTarget으로 원본 백 버퍼를 가져와 보관하고...
SetRenderTarget으로 위에서 만든 서피스를 지정한다...
그 후
BeginScene, EndScene으로 원래 하던 렌더링을 한다..
그 내용이 지정한 서피스안에 들어가게 된다..
그 후 SetRenderTarget으로 원래 백 버퍼를 복구시키고..

이 과정에서 얻은 서피스의 내용을 텍스쳐로 옮겨서
그대로 화면에 렌더링한다.. (안 그러면.. 당연히 그 프레임에는 아무것도 안나오게된다.... 서피스에만 그렸으니까)


CreateRenderTarget 함수를 쓰지 않고
RenderTarget옵션을 줘서 CreateTexture를 호출하여 텍스쳐를 바로 만들어도 된다...
대신 D3DPOOL_DEFAULT 옵션만을 지원하므로.. 귀찮은 점이 있다.. (D3DPOOL_MANAGED 가 편하다..)

나는 요청이 들어올때 마다 캡쳐를 하여 새로운 텍스쳐에 복사하도록 코딩하였다..

밑은 내가 작성한 코드를 정리한것이다.


LPDIRECT3DSURFACE9 originalTarget; // 백 버퍼
LPDIRECT3DSURFACE9 capturingTarget; // 캡쳐된 내용이 들어갈 서피스
device->GetRenderTarget(0, &originalTarget); // 가져온다..(백업?)

// 백 버퍼와 같은 속성으로 렌더타겟을 만든다.
D3DSURFACE_DESC desc;
originalTarget->GetDesc(&desc);
device->CreateRenderTarget(desc.Width, desc.Height, desc.Format, 0, 0, TRUE, &capturingTarget, NULL);

// 렌더타겟 설정후 그림.
device->SetRenderTarget(0, this->capturingTarget);
device->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1, 0);
device->BeginScene();
// 그릴 내용이 여기에..
device->EndScene();

// 여기서 텍스쳐를 만들어 캡쳐된 서피스의 내용을 복사한다...

// 원래대로 되돌린다.
device->SetRenderTarget(0, originalTarget);
device->BeginScene();
// 위에서 만든 텍스쳐를 전체화면에 그림.. 혹은 맘대로..
device->EndScene();
device->Present(NULL, NULL, NULL, NULL); 

capturingTarget->Release(); // 다 쓴 건 release.... 

아 실제로는.. capturingTarget은 한번 만들고 계속 쓰게 했다.. 마지막에 release하고..

반응형
반응형

쿼드뷰 swapchain class 정리

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

픽킹 ppt  (0) 2012.11.02
BackBuffer 와 스왑체인저  (0) 2012.11.02
정점 압축[Vertex Component Packing 처리]  (0) 2012.11.02
MFC & Directx 에서 스왑체인 멀티뷰구현  (0) 2012.11.01
MFC와 Directx 연동  (0) 2012.11.01
반응형

http://cagetu.egloos.com/4920663



Vertex Component Packing라는 쓰레드에서 보셨듯이, Nebula3를 보고 버텍스 압축을 해보았습니다.

일반적으로 버텍스 구조체를 잡으면,
    struct {
        float3 position;
        float3 normal;
        float2 uv;
        float4 skinWeights;
        float4 skinIndices;
    };
로 처리를 하는데,
    struct {
        float3 position;
        ubyte4n normal;
        short2 uv;
        ubyte4n skinWeights;
        ubyte4 skinIndices;
    };
로 압축하여 처리하는 것입니다. (다른 방법도 있지만, 네뷸라를 기준으로 합니다.)
하나의 버텍스 크기가 64Byte -> 28Byte로 줄어듭니다. 폴리곤 갯수가 많아질 수록 엄청난 차이가 생기겠지요.
대신, shader 내부에서 압축을 풀어주는 한번의 간단한 계산이 추가됩니다.

이것이 가능한 이유는 normal은 -1~1사이, uv는 0~1사이, skinWeights도 0~1 사이, skinIndices는 0~255사이의 값을 가지므로, 거의 눈에 띄지 않을 정도의 적당히 정밀도를 줄여주면, 압축이 가능합니다.

예전에 matrix pallate를 처음 접할 때, ubyte4형으로 처리하는 것을 해보셨던 분은 아시겠지만, 이것은 뭐, 새로운 기능은 아닙니다. 다만, 자원 상황이 꽤 좋은 편인 pc나 콘솔에서는 크게 사용할 이유가 없었는데, (handheld 3d작업 시에는 fixed point를 많이 사용했더군요.) 그 만큼 복잡도가 커졌다는 것이겠지요.

float -> short는 fixed point로 압축을 하면 되고요.
ubyte4 압축은 예전에 matrix pallate 작업을 해보신 분이시라면, 간단히 하실 수 있을 것이므로, 따로 이야기를 드릴 필요가 없겠군요. 주의할 것은 ubyte4와 ubyte4N의 차이를 잘 파악해야 합니다.
"UBYTE4는 bone index들을 저장하는데 좋다. 왜냐하면, 0~255 범위까지 확장이 가능하다. UBYTE4N은 같은 포멧이지만, 0~1까지만 확장이 가능하다. 그래서, 이것은 color, blendweights와 normals들에 사용하면 좋다"

[reference]
1. ShaderX - Tip and Trick - : Part2-1. 셰이더 안에서 정점 압축 풀기
2. 게임&인터랙티브 애플리케이션을 위한 수학 - fixed point
3. Modern Fixed-point Tricks and Optimizations-DevMaster.net
 
싸이월드 공감트위터페이스북

트랙백

이 글과 관련된 글 쓰기 (트랙백 보내기)
TrackbackURL : http://cagetu.egloos.com/tb/4920663 [도움말]
  • 멀티코어와 스트리밍 - 압축과 메모리 관리 2009/05/05 19:44 #

    개인적으로 게임에서 스트리밍(streaming)의 중요성과 대단함을 처음 알았던 때는 던전시즈를 끝냈을 때였다. 게임을 다시 시작하지 않는 한 로딩 없이 엔딩까지 진행할 수 있었던 게임, 그 당시의 하드웨어 환경을 사용하면 참 놀라운 일이다.이제 멀티 코어 환경의 엔진에서 스트리밍은 지원하는 것이 당연한 기본적인 특징이 되었다. 사실 다른 처리에 비하면 스트리밍은 쉬운편에 속한다. 다른 쓰레드의 잡(job)을 방해하는 일 없이 워크 쓰레드(wo...... more

  • normalmap-dxt 압축 2009/05/07 01:34 #

    Vertex Component Packing 처리에 이어서, normalmap도 압축을...NVIDIA에서 제공하는 Real-Time Normal Map DXT Compression를 많이들 읽어보셨겠지만, 아직 못 본 사람(저요.. ㅡㅡ;;)들을 위해서, 소개합니다.최근 보고 있는 Nebula3에서는 DXT5nm으로 사용하는 것이 기본으로 되어 있는데, photoshop dds plug-in 등을 이용해서, .tga등의 노말맵을 DXT5nm ...... more

덧글

  •  teze 2009/04/21 02:00 # 답글

    게임 사이드 리소스 압축에 관한 명언이 하나 있지요..
    " 무조건 압축을 해라, 그리고 결과물이 문제가 있다면 리소스를 다시 만들어라."
    한마디로 닥치고 리소스 압축은 하라는 이야기..ㅋ
  •  cagetu 2009/04/21 15:21 #

    다시 만들어달라고 하면, 만들어 줄까?? ㅎㅎ
  •  kimsama 2009/04/28 16:53 # 답글

    최근 작업 결과물 중에서 상당히 맘에 드는 결과물입니다. 스트리밍이랑 이거랑 연동해서 밀도 있는 장면 연출을 빨리 보고 싶다능... ㅋ
  •  대훈 2009/12/30 16:53 # 삭제 답글

    압축작업을 하면서 ubyte4n에 관해 검색을 해보았는데 많은 글이 콜오브듀티에서 이 기능을 사용하는데 지원하지 않는 카드라 게임을 못한다는 글이 많네요. 혹시 어떤 카드부터 지원하는지 아시는지 해서 글 남깁니다.
  •  cagetu 2009/12/31 09:31 #

    7xxx 버전 이상이면, 되는 것으로 알고 있습니다. 그러니까, 보드에 통합된 인텔 그래픽 카드가 아니면, 대략 적용된다고 볼 수 있겠죠?!
    불안하시면, 그냥 D3DCOLOR형으로 저장하셔도 됩니다.

반응형

'그래픽스(Graphics) > DirectX9~12' 카테고리의 다른 글

BackBuffer 와 스왑체인저  (0) 2012.11.02
쿼드뷰 swapchain class 정리  (0) 2012.11.02
MFC & Directx 에서 스왑체인 멀티뷰구현  (0) 2012.11.01
MFC와 Directx 연동  (0) 2012.11.01
블렌더 무료  (0) 2012.10.31
반응형

Visual studio 2010에 OpenGL 설치하기  OpenGL / Programming 

2012/06/21 12:10

복사http://blog.naver.com/nuisances/100160753081

첨부파일 (1)

OpenGL을 실행하기 위해서는 OpenGLGLU, GLUT 3개의 라이브러리가 필요하다.

 

각 라이브러리들이 어떤 기능을 하는지 살펴보면,

 

1.GL(OpenGL Core Library) : 렌더링 기능을 제공하는 함수 라이브러리로 지엘은 단지 렌더링 기능만 수행할 뿐

                                          사용자의 입력을 받는 기능과 출력하는 기능이 없다.

2.GLU(OpenGL Utility Library) : GL 함수로 작성되어 있는 고급기능을 제공하는 함수들의 집합

 

3.GLUT(OpenGL Utility Toolkit) : 사용자 입력을 받거나 화면 윈도우를 제어하기 위한 함수로 운영체제를 호출한다.

 

각각의 라이브러리는 프로그램 실행시 필요한. dll과 소스코드와의 링크를 위한 .lib 그리고 컴파일위한 헤더파일인

.h 파일로 구성되어 있다.

 

윈도우와 Visual C가 깔려 있는 상태라면 OpenGLGLU 라이브러리는 이미 설치되어 있기때문에 GLUT

라이브러리만 다운로드 받아서 설치하면 OpenGL 을 사용할 수 있다.

 

1. GLUT 라이브러리 다운로드

 

오른쪽 상단에 있는 첨부파일 사용해서 다운받으세요~







 

 

 

 

 

 

 

반응형
반응형

http://glew.sourceforge.net/

여기에서 받을 수 있으며

 

 

 

#define GL_GLEXT_PROTOTYPES

#include <gl/glew.h>
#include <gl/wglew.h>


#pragma comment(lib, "glew32.lib")

 

를 적어주면 된다

 

 

glBindBuffer    = (PFNGLBINDBUFFERARBPROC)GET_PROC_ADDRESS("glBindBuffer");
 glDeleteBuffers = (PFNGLDELETEBUFFERSARBPROC)GET_PROC_ADDRESS("glDeleteBuffers");
 glGenBuffers    = (PFNGLGENBUFFERSARBPROC)GET_PROC_ADDRESS("glGenBuffers");
 glBufferData    = (PFNGLBUFFERDATAARBPROC)GET_PROC_ADDRESS("glBufferData");

 


 glGenBuffers(1,&bufferObj);  
 glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB,bufferObj);

 glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB,DIM*DIM*4,NULL,GL_DYNAMIC_DRAW_ARB);

 

 

GET_PROC_ADDRESS 에 대한 설명은..

http://msdn.microsoft.com/en-us/library/dd374386%28v=vs.85%29.aspx

 

사용법 참고는..  http://blog.daum.net/spspoon/83


반응형
반응형

http://www.idfun.de/glut64/

 


The OpenGL Utility Toolkit (GLUT), originally written by Mark Kilgard, has been ported to Win32 (Windows 95,98,Me,NT,2000,XP) by Nate Robins and is known as GLUT for Win32

With approval of Nate his files have been extended to support both 32 and 64 bit mode in Windows using Microsoft Visual Studio 2008. It has also been tested to run with Windows Vista.

The license remains the same. Use at your own risk! 

Download


Links


Acknowlegments

  • Thanks to Alexander Reshetov for adding 64-bit support.
  • Webpage by Daniel Pohl.
This is a personal webpage and not related to any company.

반응형
반응형

http://blog.naver.com/bluefallsky/140117440732

 

 

OpenGL 오류 ,OpenGL 라이브러리, 64비트 사용자의 glut32.dll 에러  OpenGL 

2010/11/01 23:47

복사http://blog.naver.com/bluefallsky/140117440732

첨부파일 (1)

첨부파일과 아래 사이트의 링크파일은 동일합니다.

그래도 불안하신 분들을 위하여 링크해놓습니다.

공식 OpenGL 사이트 - http://www.opengl.org/resources/libraries/glut/

 

OpenGL관련

glut32.dll

glut32.lib

glut.dll

glut.h

glut.lib

파일이 없을시에 상단 링크에서

 

 

빨간 박스부분을 클릭하시고 다운로드 받으시면 됩니다.

 

추가로, 윈도7 사용자 분들께서 'glut32.dll'을 찾을수 없다는 에러로 고생하시던데

 

'System32' 폴더뿐만아니라 'SysWOW64' 폴더에 해당 dll 파일을 추가해주시면 해결됩니다

 

각 파일별 위치는 윈도7기준

*.lib    -  C:\Program Files\Microsoft SDKs\Windows\v6.0A\Lib

glut.h  -  C:\Program Files\Microsoft SDKs\Windows\v6.0A\Include\gl

*.dll    -  C:\Windows\SysWOW64

          -  C:\Windows\System32

 


 

 

 

http://the2384.blog.me/10133610049

 


OpenGL을 설치해보자.  ♬ OpenGL / # 컴퓨터 

2012/03/05 20:17

복사http://the2384.blog.me/10133610049

첨부파일 (2)

# 참고 : 이 방법은 VS 2010 Version에 적용되는 것입니다.

VS 2009나 하위 버전에 대한 것은 참고 사이트 2번째 링크에 들어가셔서 확인하시길 바랍니다.


○ SDK 설치 (아래의 링크 참조)

아래의 링크에서도 받을 수 있고 이 게시물의 첨부파일에서 받으셔도 무방합니다. (2012.3.5)

http://www.opengl.org/resources/libraries/glut/glut_downloads.php


주의 : 64bit, 32bit 즉, 운영체제에 따라 다른 파일 경로에 설치될 수 있습니다.


압축을 풀게되면 .dll, .h, .lib파일이 나오는데 해당 경로로 이동하셔서 파일을 옮겨 주시면 됩니다.

.dll = C:\Windows\system32

.h = C:\Program Files(x86)\Microsoft SDKs\Windows\v7.0A\Include\gl

.h = C:\Program Files(x86)\Microsoft SDKs\Windows\v7.0A\Include (위의 두 경로 모두)

(OpenGL 관련한 확장 라이브러리가 많기 때문에 별도로 폴더 만들어서 관리할 것.)

.lib = C:\Program Files\Microsoft SDKs\Windows\v7.0A\Lib


참고 사이트

http://gcland.tistory.com/123

http://whiteday910.blog.me/40126539277

 

SDK를 모두 설치했다면 샘플 코드를 돌려보시면 됩니다.

- 64비트 OS 사용자는 시스템에 glut32.dll이 없다고 뜰 수 있는데 그 경우엔 sysWOW64(C경로)에 dll파일을 복사하셔서 넣어 주시면 되겠습니다.


샘플 코드는 첨부파일을 참고 하시길 바랍니다.

[출처] OpenGL을 설치해보자.|작성자 히단


 


 

http://towanouta.tistory.com/128

 


 헤더 파일 LIB 파일  DLL 파일 
    glut.h     glut.lib    glut.dll
    GL.h    glut32.lib    glut32.dll
    GLU.h    GLU32.lib    GLU32.dll
    GLAUX.h    GLAUX.lib    OPENGL32.dll
     OPENGL32.lib 


※ 설치법
    간단히 위의 파일들을 적절한 위치에 붙여넣기만 하면 됩니다.

● 헤더파일 : 
       C:\Program Files\Microsoft Visual Studio\VC\include\gl 또는
       
C:\Program Files\Microsoft Visual Studio\VC\include      에 붙여 넣어 주시면 됩니다.

● 
LIB 파일 : 
       C:\Program Files\Microsoft Visual Studio\VC\lib  에 붙여넣기

● DLL 파일 :
      32bit 운영체제 일 경우엔 
           C:\Windows\System32 에만 붙여넣기
      64bit 운영체제( 윈도7 기준 )
           C:\Windows\SysWOW64 에도 붙여넣기를 해주시면 됩니다.


64bit운영체제에서 SysWOW64폴더에 DLL파일을 붙여넣어 주지 않으면 제대로 작동이 되지 않을 수도 있습니다. 


그리고 비주얼 스튜디오에서 다음의 추가 종속성을 설정해 주시면 됩니다.

● 프로젝트 - 속성 - 구성속성 - 링커 - 입력 - 추가 종속성    에서 다음을 추가해주시면 됩니다.
opengl32.lib  glut32.lib  glu32.lib


반응형

+ Recent posts