'프로그래밍'에 해당되는 글 59건

  1. 2008.08.26 물리 시뮬레이션!! 6
  2. 2008.08.23 리얼 해 보이나요? 2
  3. 2008.08.06 NVIDIA GPU-BBQ 2008을 다녀와서...
  4. 2008.07.21 버택스 버퍼를 다중 스트림으로 사용하기
  5. 2008.07.21 데칼에 범프맵 적용하는 작업을 하려다 보니
  6. 2008.07.19 DXUT D3D 10 NVIDIA PerfHUD 6 Launcher 적용해보기 1
  7. 2008.07.15 문자열 파싱관련 자료 링크
  8. 2008.07.15 링크 에러~ libcmt.lib에 이미 포함되고 어쩌구 거리면
  9. 2008.07.03 http://www.renderman.org/
2008. 8. 26. 09:05

물리 시뮬레이션!!



 울 겜에 적용하면 안 어울리려낭??
2008. 8. 23. 19:56

리얼 해 보이나요?



리얼한것 같은데 일단 저해상도라서 패스~
2008. 8. 6. 10:11

NVIDIA GPU-BBQ 2008을 다녀와서...

 회사에서 같다가 오래서 다녀왔습니다.
 세미나를 몇번 참석해 봤는데요, 근 2년안쪽에서는 정말 좋고, 도움이 새미나였습니다.

회사에서 써 낸 보고서를 인용하며 몇 줄 더 적어보면...

간단한 소감

 기존 작업에도 적용할 수 있는 퍼포먼스 최적화는 유용했으며, 차후 D3D 11에서 지원될 테슬레이션에대해 접해볼 수 있는 좋은 시간이었습니다. CUDA에 관련해 관심을 가질 수 있는 기회였으며, 앞으로 출시될 PhysX의 시연 동영상도 볼 수 있었습니다.


Agenda
순으로 정리하겠습니다.

 

1.     엔비디아 회사소개 및 상품소개

2.     퍼포먼스 최적화, D3D10 맛보기

3.     D3D11 & 테슬레이션

4.     CUDA

5.     엔비디아 PhysX


 

1.     엔비디아 회사소개 & 상품소개

 

 아시아 총책임자인 케이타 이다의 회사 소개가 있었음.

 그래픽 카드 홍보.

   사견?
      4850개열에 발리고 있는 상황에서도 음.... 엔비디아가 짱이라는 식을 소개라서.... 좀 의외였음
      개발자 지원은 솔직히 인정하는데 결국 가격대 성능비가 좋아야 게이머들이 사지 않을까?

 

2.     퍼포먼스 최적화, D3D10 맛보기

 

-       퍼포먼스 최적화 방법 소개

개임 실행중의 리소스 생성 및 파괴의 최소화

 

-       병목현상을 제거하는 방법

PerfHuD Frame Profiler를 사용하라

Input Assembly(데이터 인풋), 내부에서 대이터의 전송 병목현상 대처방법 소개

VS, GS, PS의 병목 현상 대처방법소개

기타 이유에 대한 소개

 

-       D3D 10

D3D9-10으로 단순한 포팅작업 만으로는 성능향상을 볼 수 없다.(설계부터 꼼꼼히)

비스타 드라이버 모델은 스케줄러가 메모리 관리를 OS가 전담.

Depth를 따로 그릴 필요가 없어짐

사견?
진짜 주옥같은 시간이라 여겨짐. 알고있는 내용 90%에 10%정도는 배웠는데, 10%가 어디야!!

3.     테슬레이션 DX11

 

Subdivision Surfaces – Displacement Mapping 소개

Subdivision Surfaces

 매쉬 자체의 수준을 높인다. Low폴리곤의 매쉬를 베이어 곡선화된 High폴리곤으로

 

 이 기능을 위해 DX11에서는

           HS (HULL Shader)

           TS 텔슬레이션

           DS (Domain Shader )

       세가지의 새로운 Shader스테이지가 생겼고 HS, DS는 프로그래밍이 가능하다.

     

Subdivision Surfaces을 준비하기 위한 면을 정리하는 방법에 대한 설명이 있었음.

 맥스 & 마야등에서 이미 이에 대한 지원이 있음.

DX11는 이와 같은 작업을 위해 새로운 형태의 DrawPrimitve를 지원 (Quad)

 

Displacement Mapping

 쉽게 말하면 노말맵과 비슷한 기술. 매핑하는 기술임


사견?
아쉬파, DX11언제또 보나 이제와서야 DX10끄적거리고 있는데


 

4.     CUDA

엔비디아 GPU CPU처럼 이용(GPGPU)해 좀더 좋은 성능을 프로그램을 만들고자함.

 

장점.

   GPU는 원래 병렬 연산의 위한 구조로 설계(쓰레드 프로그래밍 고려)

    최대 23.000개의 스래드 동시 구용 1TELOP의 연산능력

   CUDA가 지원하는 언어는 C++과 유사(다른 쉐이딩 언어를 배울 필요가 없음)

단점.

           엔비디아 8000대 이상에서만 지원(기타 그래픽 카드에선 안됨)

           SLI모드와 아닌 경우의 차이가 많다.

          

MS에서도 DX11을 출시와 함께 DX11 Compute Shader Cuda와 비슷한 상품군을 내놓고 있습니다.

 

 EX)

1.     HDR 툰 매핑을 경우 휘도를 추출하는 부분을 CUDA로 연산하면 소개자 말로는 10정도의 성능향상이 있다고 함. 벨브 소스엔진의 PP부분에서는 이미 적용하여 사용한다고 합니다.

2.     다중 AI에 적용 시, 많은 UNIT이 동시에 길찻기를 CUDA를 이용하여 하는 방법을 선보였습니다.

3.     유체 연산, 연기효과등


        사견?
          CUDA에 관심이 없었는데 관심을 가지게 되는 계기가됨. 할수 있으면 울 플젝 PP에도 적용해 보고 싶음. 사실 CUDA때문에 DX11 Compute shader을 해야겠다는 생각이 더욱 들더라....

 

5.     PhysX

 

엔비디아가 인수한 후 PhysX의 앞으로의 발전방향에 대해서 언급

 

상위버전에서 추가된 기능

드라이버 별도 설치 불필요

           향상된 천 효과

           유체효과

           물효과

 

           AgPerfmon, AgPerfHud, Apex등 최적화용 툴 지원

 

           각종 미들외어와 연계된 효과

             Q3버전이후 스피드 트리와 연계 시 힘을 가함에 있어 나무가 움직이며 파괴가 됨


        사견?
        피씨 버전은 공짜데 안쓰는게 이상한듯



  느낀점.
   1. 질문시간에 한글로 만하면 분명히 통역해주는데도 안되는 영어로 말하는 개발자들을 보면서, 내가 민망스럽더라. 영어공부하려온것도 아니고, 아니면 한글도 그정도 수준으로 말하나?

   2. 밥은 8000원짜리를 주던데 맛이 없더라.

   3. 가격대 성능비가 안나와서 이제 점차 위축될꺼라 생각한 엔비디아였는데, 음... 앞으로 어떻게 될까?

  이상입니다.

 이글은 퍼가시면 안됩니다~~

2008. 7. 21. 11:19

버택스 버퍼를 다중 스트림으로 사용하기

다중 스트림으로 사용하면 편리한 경우가 많다.


/////////////////
// 초기화...
/////////////////

// 정점 선언
D3DVERTEXELEMENT9 decl_tex1[] =
{
{0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT , D3DDECLUSAGE_POSITION , 0},
{1, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT , D3DDECLUSAGE_NORMAL , 0},
{2, 0, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR , 0},
{3, 0, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT , D3DDECLUSAGE_TEXCOORD , 0},
D3DDECL_END()
};
g_pDevice->CreateVertexDeclaration( decl_tex1 , &g_pVD_Tex1 );

// 각 요소별로 버퍼만들기

hr = g_pDevice->CreateVertexBuffer( sizeof( D3DXVECTOR3 ) * nVerCount ,
D3DUSAGE_WRITEONLY , D3DFVF_XYZ ,D3DPOOL_MANAGED , &m_pVB_Pos , NULL );
if( FAILED(hr) )
return 0;

// nor
hr = g_pDevice->CreateVertexBuffer( sizeof( D3DXVECTOR3 ) * nVerCount ,
D3DUSAGE_WRITEONLY , D3DFVF_NORMAL ,D3DPOOL_MANAGED , &m_pVB_Nor , NULL );
if( FAILED(hr) )
return 0;


// color
hr = g_pDevice->CreateVertexBuffer( sizeof( DWORD ) * nVerCount ,
D3DUSAGE_WRITEONLY , D3DFVF_DIFFUSE ,D3DPOOL_MANAGED , &m_pVB_Col , NULL );
if( FAILED(hr) )
return 0;

// tex1
hr = g_pDevice->CreateVertexBuffer( sizeof( D3DXVECTOR2 ) * nVerCount ,
D3DUSAGE_WRITEONLY , D3DFVF_TEX0 | D3DFVF_TEXCOORDSIZE2(0) ,D3DPOOL_MANAGED , &m_pVB_Tex1 , NULL );
if( FAILED(hr) )
return 0;

어떤 물체를 범프맵으로 그렸다가 안그렸다가 할때도 구지 전부 셋을 할 필요없이, 필요한 요소만 셋하면 된다.

버텍스 버퍼 다중 스트림으로 사용하면 호율적이고 빠른가요?
http://www.gpgstudy.com/forum/viewtopic.php?t=19317

성능차도 거의 없다던데...
2008. 7. 21. 11:10

데칼에 범프맵 적용하는 작업을 하려다 보니

엔진에 데칼을 붙이이 작업을 저번에 한번 해서 이번에 그래픽파트 요구사항으로

데칼에 범프맵을 적용하게 되었습니다. 맥스에서 익스포트하는 유닛을은 탄젠트가 그냥 빠져서 편할것 같은데, 데칼은 직접 탄젠트를 구해줘야 할것 같아서, 책을 뒤적거라다가 인터넷에서 다음과 같은 페이지를 찻았습니다.

http://www.terathon.com/code/tangent.html

Computing Tangent Space Basis Vectors for an Arbitrary Mesh

흠... 위에부분만 보고 책에 나온거랑 완전 똑같다면서 욕하고 있었는데 아랬부분에 왠 쏘스가???

우왕ㅋ 굿ㅋ

Computing Tangent Space Basis Vectors for an Arbitrary Mesh

Modern bump mapping (also known as normal mapping) requires that tangent plane basis vectors be calculated for each vertex in a mesh. This article presents the theory behind the computation of per-vertex tangent spaces for an arbitrary triangle mesh and provides source code that implements the proper mathematics.

Mathematical Derivation

[This derivation also appears in Mathematics for 3D Game Programming and Computer Graphics, 2nd ed., Section 6.8.]

We want our tangent space to be aligned such that the x axis corresponds to the u direction in the bump map and the y axis corresponds to the v direction in the bump map. That is, if Q represents a point inside the triangle, we would like to be able to write

QP0 = (uu0)T + (vv0)B,

where T and B are tangent vectors aligned to the texture map, P0 is the position of one of the vertices of the triangle, and (u0, v0) are the texture coordinates at that vertex. The letter B stands for bitangent, but in many places it is stilled called binormal because of a mix-up in terms when tangent-space bump mapping first became widespread. (See “Bitangent versus Binormal” below.)

Suppose that we have a triangle whose vertex positions are given by the points P0, P1, and P2, and whose corresponding texture coordinates are given by (u0, v0), (u1, v1), and (u2, v2). Our calculations can be made much simpler by working relative to the vertex P0, so we let

Q1 = P1P0
Q2 = P2P0

and

(s1, t1) = (u1u0, v1v0)
(s2, t2) = (u2u0, v2v0).

We need to solve the following equations for T and B.

Q1 = s1T + t1B
Q2 = s2T + t2B

This is a linear system with six unknowns (three for each T and B) and six equations (the x, y, and z components of the two vector equations). We can write this in matrix form as follows.

  (Q1)x
(Q2)x
(Q1)y
(Q2)y
(Q1)z
(Q2)z
  =   s1
s2
t1
t2
      Tx
Bx
Ty
By
Tz
Bz
 

Multiplying both sides by the inverse of the (s, t) matrix, we have

  Tx
Bx
Ty
By
Tz
Bz
  = 1
s1t2s2t1
  t2
−s2
−t1
s1
      (Q1)x
(Q2)x
(Q1)y
(Q2)y
(Q1)z
(Q2)z
  .

This gives us the (unnormalized) T and B tangent vectors for the triangle whose vertices are P0, P1, and P2. To find the tangent vectors for a single vertex, we average the tangents for all triangles sharing that vertex in a manner similar to the way in which vertex normals are commonly calculated. In the case that neighboring triangles have discontinuous texture mapping, vertices along the border are generally already duplicated since they have different mapping coordinates anyway. We do not average tangents from such triangles because the result would not accurately represent the orientation of the bump map for either triangle.

Once we have the normal vector N and the tangent vectors T and B for a vertex, we can transform from tangent space into object space using the matrix

  Tx
Ty
Tz
Bx
By
Bz
Nx
Ny
Nz
  .

To transform in the opposite direction (from object space to tangent space—what we want to do to the light direction), we can simply use the inverse of this matrix. It is not necessarily true that the tangent vectors are perpendicular to each other or to the normal vector, so the inverse of this matrix is not generally equal to its transpose. It is safe to assume, however, that the three vectors will at least be close to orthogonal, so using the Gram-Schmidt algorithm to orthogonalize them should not cause any unacceptable distortions. Using this process, new (still unnormalized) tangent vectors T′ and B′ are given by

T′ = T − (N · T)N
B′ = B − (N · B)N − (T′ · B)T′

Normalizing these vectors and storing them as the tangent and bitangent for a vertex lets us use the matrix

  T′x
B′x
Nx
T′y
B′y
Ny
T′z
B′z
Nz
       (*)

to transform the direction to light from object space into tangent space. Taking the dot product of the transformed light direction with a sample from the bump map then produces the correct Lambertian diffuse lighting value.

It is not necessary to store an extra array containing the per-vertex bitangent since the cross product N × T′ can be used to obtain mB′, where m = ±1 represents the handedness of the tangent space. The handedness value must be stored per-vertex since the bitangent B′ obtained from N × T′ may point in the wrong direction. The value of m is equal to the determinant of the matrix in Equation (*). One may find it convenient to store the per-vertex tangent vector T′ as a four-dimensional entity whose w coordinate holds the value of m. Then the bitangent B′ can be computed using the formula

B′ = T′w(N × T′),

where the cross product ignores the w coordinate. This works nicely for vertex programs by avoiding the need to specify an additional array containing the per-vertex m values.

Bitangent versus Binormal

The term binormal is commonly used as the name of the second tangent direction (that is perpendicular to the surface normal and u-aligned tangent direction). This is a misnomer. The term binormal pops up in the study of curves and completes what is known as a Frenet frame about a particular point on a curve. Curves have a single tangent direction and two orthogonal normal directions, hence the terms normal and binormal. When discussing a coordinate frame at a point on a surface, there is one normal direction and two tangent directions, which should be called the tangent and bitangent.

Source Code

The code below generates a four-component tangent T in which the handedness of the local coordinate system is stored as ±1 in the w-coordinate. The bitangent vector B is then given by B = (N × T) · Tw.

#include "Vector4D.h"


struct Triangle
{
    unsigned short  index[3];
};


void CalculateTangentArray(long vertexCount, const Point3D *vertex, const Vector3D *normal,
        const Point2D *texcoord, long triangleCount, const Triangle *triangle, Vector4D *tangent)
{
    Vector3D *tan1 = new Vector3D[vertexCount * 2];
    Vector3D *tan2 = tan1 + vertexCount;
    ZeroMemory(tan1, vertexCount * sizeof(Vector3D) * 2);
    
    for (long a = 0; a < triangleCount; a++)
    {
        long i1 = triangle->index[0];
        long i2 = triangle->index[1];
        long i3 = triangle->index[2];
        
        const Point3D& v1 = vertex[i1];
        const Point3D& v2 = vertex[i2];
        const Point3D& v3 = vertex[i3];
        
        const Point2D& w1 = texcoord[i1];
        const Point2D& w2 = texcoord[i2];
        const Point2D& w3 = texcoord[i3];
        
        float x1 = v2.x - v1.x;
        float x2 = v3.x - v1.x;
        float y1 = v2.y - v1.y;
        float y2 = v3.y - v1.y;
        float z1 = v2.z - v1.z;
        float z2 = v3.z - v1.z;
        
        float s1 = w2.x - w1.x;
        float s2 = w3.x - w1.x;
        float t1 = w2.y - w1.y;
        float t2 = w3.y - w1.y;
        
        float r = 1.0F / (s1 * t2 - s2 * t1);
        Vector3D sdir((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r,
                (t2 * z1 - t1 * z2) * r);
        Vector3D tdir((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r,
                (s1 * z2 - s2 * z1) * r);
        
        tan1[i1] += sdir;
        tan1[i2] += sdir;
        tan1[i3] += sdir;
        
        tan2[i1] += tdir;
        tan2[i2] += tdir;
        tan2[i3] += tdir;
        
        triangle++;
    }
    
    for (long a = 0; a < vertexCount; a++)
    {
        const Vector3D& n = normal[a];
        const Vector3D& t = tan1[a];
        
        // Gram-Schmidt orthogonalize
        tangent[a] = (t - n * Dot(n, t)).Normalize();
        
        // Calculate handedness
        tangent[a].w = (Dot(Cross(n, t), tan2[a]) < 0.0F) ? -1.0F : 1.0F;
    }
    
    delete[] tan1;
}

How to cite this article

Lengyel, Eric. “Computing Tangent Space Basis Vectors for an Arbitrary Mesh”. Terathon Software 3D Graphics Library, 2001. http://www.terathon.com/code/tangent.html

2008. 7. 19. 15:54

DXUT D3D 10 NVIDIA PerfHUD 6 Launcher 적용해보기

#if SHIPPING_VERSION
    // When building a shipping version, disable PerfHUD (opt-out)
    #else
    // Look for 'NVIDIA PerfHUD' adapter
    // If it is present, override default settings
   
    IDXGIFactory *pDXGIFactory;
    ID3D10Device *pDevice;
    HRESULT hRes;
    hRes = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&pDXGIFactory);
   
    // Search for a PerfHUD adapter.
    UINT nAdapter = 0;
    IDXGIAdapter* adapter = NULL;
    IDXGIAdapter* selectedAdapter = NULL;
    D3D10_DRIVER_TYPE driverType = D3D10_DRIVER_TYPE_HARDWARE;

    while (pDXGIFactory->EnumAdapters(nAdapter, &adapter) != DXGI_ERROR_NOT_FOUND)
    {
     if (adapter)
     {
      DXGI_ADAPTER_DESC adaptDesc;
      if (SUCCEEDED(adapter->GetDesc(&adaptDesc)))
      { const bool isPerfHUD = wcscmp(adaptDesc.Description, L"NVIDIA PerfHUD") == 0;
     
      // Select the first adapter in normal circumstances or the PerfHUD one if it exists.
     
      if(nAdapter == 0 || isPerfHUD)
       selectedAdapter = adapter;
     
      if(isPerfHUD)
       driverType = D3D10_DRIVER_TYPE_REFERENCE;
      }
     }
     ++nAdapter;
    }
    #endif
   
    //if(FAILED(D3D10CreateDevice( selectedAdapter, driverType, NULL, 0, D3D10_SDK_VERSION, &pDevice))) return E_FAIL;

    // If D3D10.1 doesn't exist, then fallback to D3D10.0
                hr = DXUT_Dynamic_D3D10CreateDevice( selectedAdapter, driverType, NULL, 0, NULL, D3D10_SDK_VERSION, &pd3d10Device );

                //// If D3D10.1 doesn't exist, then fallback to D3D10.0
                //hr = DXUT_Dynamic_D3D10CreateDevice( pAdapter, pNewDeviceSettings->d3d10.DriverType, ( HMODULE )0,
                //                                     pNewDeviceSettings->d3d10.CreateFlags,
                //                                     NULL, D3D10_SDK_VERSION, &pd3d10Device );

일단 이렇게만 하니까 되긴 하던데 펌프후드 실행한뒤에 머가 재대로 안되는듯...
차후 수정해서 정보 갱신하겠습니다.

2008. 7. 15. 11:16

문자열 파싱관련 자료 링크


http://choiks.tistory.com/trackback/35

문자열 파싱관련 좋은 자료인듯 합니다.
       
2008. 7. 15. 10:43

링크 에러~ libcmt.lib에 이미 포함되고 어쩌구 거리면

1.모든 프로젝트의 코드 제너레이션을 다 맞춘다.
다중 쓰레드 디버그
다중쓰레드 디버그 dll
등등..
모든 프로젝트의 코드 제너레이셩 (코드 생성)을 똑같이 맞춘다.

뭔저 이걸 해보고


2.문자열 유형을 다 맞춘다.
멀티 바이트 유니코드로 되어 있을것이다 .
모든 프로젝트의 문자열 생성을 똑같이 맞춘다.


3. 만약 엠에프씨를 사용한다면 엠에프씨 코드 생성을 똑같이 맞춘다.
공유 DLL에서 MFC 사용
정적 라이브러리 생성
등..
모두 똑같이 맞추고 컴파일 한다.

그 이상은 또 추가적으로 해서 잡아봅시다!
2008. 7. 3. 18:42

http://www.renderman.org/

http://www.renderman.org/

3D 그래픽스 프로그래밍 관련 사이트

Shader 예제들이 있네욧!