Vertex를 이용한 Wave 만들기 

Vertices.cpp
//-----------------------------------------------------------------------------
// File: Vertices.cpp
//
// Desc: In this tutorial, we are rendering some vertices. This introduces the
//       concept of the vertex buffer, a Direct3D object used to store
//       vertices. Vertices can be defined any way we want by defining a
//       custom structure and a custom FVF (flexible vertex format). In this
//       tutorial, we are using vertices that are transformed (meaning they
//       are already in 2D window coordinates) and lit (meaning we are not
//       using Direct3D lighting, but are supplying our own colors).
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#include <d3d9.h>
#include <d3dx9.h>
#include <stdio.h>
#pragma warning( disable : 4996 ) // disable deprecated warning 
#include <strsafe.h>
#pragma warning( default : 4996 ) 

#include "Wave.h"




//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
LPDIRECT3D9             g_pD3D       = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; // Our rendering device
// LPDIRECT3DVERTEXBUFFER9 g_pVB        = NULL; // Buffer to hold vertices

CHAR g_Key[256] = {0,};
FLOAT MoveX, MoveY;

CWave Wave;




//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
	// Create the D3D object.
	if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
		return E_FAIL;

	// Set up the structure used to create the D3DDevice
	D3DPRESENT_PARAMETERS d3dpp;
	ZeroMemory( &d3dpp, sizeof(d3dpp) );
	d3dpp.Windowed = TRUE;
	d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
	d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

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

	// Device state would normally be set here

	// 선으로 보여주기 디폴트 D3DFILL_SOLID
	//	g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME ); 


	return S_OK;
}




//-----------------------------------------------------------------------------
// Name: InitVB()
// Desc: Creates a vertex buffer and fills it with our vertices. The vertex
//       buffer is basically just a chuck of memory that holds vertices. After
//       creating it, we must Lock()/Unlock() it to fill it. For indices, D3D
//       also uses index buffers. The special thing about vertex and index
//       buffers is that they can be created in device memory, allowing some
//       cards to process them in hardware, resulting in a dramatic
//       performance gain.
//-----------------------------------------------------------------------------
HRESULT InitVB()
{
	MoveX = MoveY = 0.0f;

	Wave.InitVB( g_pd3dDevice, MoveX , MoveY);
		
	return S_OK;
}





//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{

	Wave.CleanUp();

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

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


//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
VOID Render()
{
	 Wave.UpDate( MoveX, MoveY );

	 g_Key['A'] ? g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME ) : 
					 g_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID ); 

	// Clear the backbuffer to a blue color
	 g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );


	// Begin the scene
	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	{
		// Draw the triangles in the vertex buffer. This is broken into a few
		// steps. We are passing the vertices down a "stream", so first we need
		// to specify the source of that stream, which is our vertex buffer. Then
		// we need to let D3D know what vertex shader to use. Full, custom vertex
		// shaders are an advanced topic, but in most cases the vertex shader is
		// just the FVF, so that D3D knows what type of vertices we are dealing
		// with. Finally, we call DrawPrimitive() which does the actual rendering
		// of our geometry (in this case, just one triangle).

		Wave.Render(g_pd3dDevice);


		// End the scene
		g_pd3dDevice->EndScene();
	}

	// Present the backbuffer contents to the display
	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_KEYDOWN:
		{
			g_Key[wParam] = 1;
		}
		break;
	case WM_KEYUP:
		{
			g_Key[wParam] = 0;
		}
		break;

	case WM_DESTROY:
		Cleanup();
		PostQuitMessage( 0 );
		return 0;
	}

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




//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: The application's entry point
//-----------------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
	// Register the window class
	WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
		GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
		"D3D Tutorial", NULL };
	RegisterClassEx( &wc );

	// Create the application's window
	HWND hWnd = CreateWindow( "D3D Tutorial", "D3D Tutorial 02: Vertices",
		WS_OVERLAPPEDWINDOW, 100, 100, 600, 600,
		NULL, NULL, wc.hInstance, NULL );

	// Initialize Direct3D
	if( SUCCEEDED( InitD3D( hWnd ) ) )
	{
		// Create the vertex buffer
		if( SUCCEEDED( InitVB() ) )
		{
			// Show the window
			ShowWindow( hWnd, SW_SHOWDEFAULT );
			UpdateWindow( hWnd );

			// Enter the message loop
			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( "D3D Tutorial", wc.hInstance );
	return 0;
}



Wave.h
#pragma once

#include <d3d9.h>
#include &ld3dx9.h>
#include &lstdio.h>

// A structure for our custom vertex type
struct CUSTOMVERTEX
{
	FLOAT x, y, z, rhw; // The transformed position for the vertex
	DWORD color;        // The vertex color
};

// Our custom FVF, which describes our custom vertex structure
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)


class CWave
{

private:
	LPDIRECT3DDEVICE9       m_pd3dDevice;
	LPDIRECT3DVERTEXBUFFER9 m_pVB; 

	FLOAT Radius;
	FLOAT Angle;
	FLOAT Add;

	CUSTOMVERTEX vertices[24];

public:
	FLOAT Speed;

	CWave();
	~CWave();

	HRESULT InitVB(LPDIRECT3DDEVICE9, FLOAT MoveX, FLOAT MoveY);
	VOID Render(LPDIRECT3DDEVICE9);
	VOID CleanUp();
	VOID UpDate(FLOAT MoveX, FLOAT MoveY);

};


Wave.cpp
#include "Wave.h"
CWave::CWave() {} CWave::~CWave() {} HRESULT CWave::InitVB(LPDIRECT3DDEVICE9 m_pd3dDevice, FLOAT MoveX , FLOAT MoveY) { Speed = 20.0f; Add = 20.0f; Radius = 10.0f; Angle = 0.0f; // Initialize three vertices for rendering a triangle for( int i=0; i<12; ++i ) { vertices[i*2].x = 50.0f + MoveX ; vertices[i*2].y = 350.0f + (sinf(D3DXToRadian(Angle)) * Add); vertices[i*2].z = 0.5f; vertices[i*2].rhw = 0.5f; vertices[i*2].color = 0xffff0000; vertices[i*2+1].x = 50.0f + MoveX; vertices[i*2+1].y = 300.0f + (sinf(D3DXToRadian(Angle)) * Add); vertices[i*2+1].z = 0.5f; vertices[i*2+1].rhw = 0.5f; vertices[i*2+1].color = 0xffff0000; MoveX+=50; Angle += 30.0f; } if( FAILED( m_pd3dDevice->CreateVertexBuffer( 24*sizeof(CUSTOMVERTEX), 0, D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &m_pVB, NULL ) ) ) { return E_FAIL; } return S_OK; } VOID CWave::CleanUp() { if( m_pVB != NULL ) m_pVB->Release(); } VOID CWave::Render(LPDIRECT3DDEVICE9 m_pd3dDevice) { m_pd3dDevice->SetStreamSource( 0, m_pVB, 0, sizeof(CUSTOMVERTEX) ); m_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX ); m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 20 ); } VOID CWave::UpDate( FLOAT MoveX, FLOAT MoveY) { CUSTOMVERTEX* pVertices; if( FAILED( m_pVB->Lock( 0, sizeof(vertices), (void**)&pVertices, 0 ) ) ) memcpy( pVertices, vertices, sizeof(vertices) ); MoveX = 0.0f; for( int i=0; i<12; ++i ) { pVertices[i*2].x = 50.0f + MoveX ; pVertices[i*2].y = 350.0f + (sinf(D3DXToRadian(Angle)) * Add ); pVertices[i*2].z = 0.5f; pVertices[i*2].rhw = 0.5f; pVertices[i*2].color = 0xffff0000 >> i; pVertices[i*2+1].x = 50.0f + MoveX; pVertices[i*2+1].y = 300.0f + (sinf(D3DXToRadian(Angle)) * Add); pVertices[i*2+1].z = 0.5f; pVertices[i*2+1].rhw = 0.5f; pVertices[i*2+1].color = 0xffff0000 >> i; MoveX+=50; Angle+=30.0f; } Angle+=Speed; m_pVB->Unlock(); }
신고
by Private: 2011.07.24 11:50

티스토리 툴바