http://www.cyworld.com/romejune/5142517
//////////////////////////////////////////////////////////////////////////////////////////////////
//
// File: pSystem.h
//
// Author: Frank Luna (C) All Rights
Reserved
//
// System: AMD Athlon 1800+ XP, 512 DDR, Geforce 3, Windows
XP, MSVC++ 7.0
//
// Desc: Represents a geneal particle
system.
//
//////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef __pSystemH__
#define __pSystemH__
#include "d3dUtility.h"
#include "camera.h"
#include <list>
namespace psys
{
////파티클의 위치와 컬러를 표현하는 데의 구조체
포맷.
struct Particle
{
D3DXVECTOR3
_position;
D3DCOLOR _color;
static const DWORD
FVF;
};
struct
Attribute
{
Attribute()
{
_lifeTime = 0.0f;
_age
= 0.0f;
_isAlive = true;
}
// 파티클과 파티클의 속성들.
// 파티클을 렌더링하는데 필요한 데이터와 파티클 속성을 별도의 구조체 내에 보관하게 되는데,
// 파티클을
만들고 파괴하고 갱신할 때는 바로 이러한 속성을 이용해 작업하는 것이며,
// 이를 렌더링할 준비가 완료되면 Particle 구조체로
위치와 속성을 복사해 이용.
D3DXVECTOR3 _position; // 월드 스페이스 내의 파티클
위치.
D3DXVECTOR3 _velocity; // 파티클의 속도, 보통은
초당 이동 단위로 기록.
D3DXVECTOR3 _acceleration; // 파티클의
가속. 보통은 초당 이동 단위로 기록.
float _lifeTime; // 파티클이 소멸할 때까지 유지되는 시간.
// 예, 레이저 빔 파티클은 특정한 시간동안만 유지.
float
_age; // 파티클의 현재 나이
D3DXCOLOR
_color; // 파티클의 컬러
D3DXCOLOR
_colorFade; // 파티클의 컬러가 시간의 흐름에 따라 퇴색하는
방법
bool _isAlive; // 파티클이 생존한 경우 true,
소멸한 경우 false
};
// 파티클 시스템의 요소들.
// 파티클 시스템은 파티클들의 모임이며 파티클을
보여주고 관리하는 역할을 담당한다.
// 파티클의 크기나 파티클 원천의 위치, 파티클에 적용할 텍스처 등
// 시스템 내의 모든
파티클에 영향을 주는 전역 특성들을 관리.
// 기능적 관점에서 보면
// 파티클 갱신과 디스플레이, 소멸, 생성 등을 관장하는
역할.
class PSystem
{
public:
// 디폴트 값을 초기화하는
생성자와
// 장치 인터페이스 (버텍스 버퍼, 텍스처)를 해제하는
디스트럭터
PSystem();
virtual ~PSystem();
// init - 포인트 스프라이트를 저장하기 위한 버텍스 버퍼를 만들고
// 텍스처를
만드는 등의 Direct3D의 장치 의존적인 초기화 작업을 처리.
virtual bool
init(IDirect3DDevice9* device, char* texFileName);
// 시스템 내의 모든 파티클 속성을 리셋.
virtual void
reset();
virtual void resetParticle(Attribute* attribute) = 0;
// 시스템에 파티클을 추가.
virtual void
addParticle();
// 시스템 내의 모든 파티클들을 갱신.
virtual void
update(float timeDelta) = 0;
// 렌더링에 앞서 지정해야 할 초기 렌더 상태를 지정.
// 이 메서드는 시스템에 따라
달라질 수 있으므로 가상 함수로 선언.
virtual void preRender();
// 시스템 내의 모든 파티클들을 렌더링
virtual void
render();
// 특정 파티클 시스템이 지정했을 수 있는 렌더 상태를 복구하는 데 이용.
// 이
메서드는 시스템에 따라 달라질 수 있으므로 가상 메서드로 선언.
virtual void postRender();
// 현재 시스템에 파티클이 없는 경우 true 리턴.
bool
isEmpty();
// 시스템 내의 파티클이 모두 죽은 경우 true 리턴.
bool
isDead();
protected:
// 속성 리스트 _particle을 검색하여 죽은 파티클을 리스트에서
제거.
virtual void removeDeadParticles();
protected:
IDirect3DDevice9*
_device;
D3DXVECTOR3 _origin; // 시스템의 원천,
시스템 내에서 파티클이 시작되는 곳.
d3d::BoundingBox _boundingBox; // 파티클이 이동할 수 있는 부피를 제한하는 데 이용.
// 예, 산 정상을 둘러싼 지역에만 눈이 오는 시스템.
// 원하는 영역을 경계상자로 정의하면 이 영역을
벗어난 파티클들을 곧바로 소멸.
float _emitRate; // 시스템에 새로운 파티클이 추가되는 비율. 보통은 초당 파티클 수로
기록.
float _size; // 시스템
내 모든 파티클의 크기
IDirect3DTexture9*
_tex;
IDirect3DVertexBuffer9* _vb;
std::list<Attribute>
_particles; // 시스템 내 파티클 속성의 리스트.
// 우리는 파티클을 만들고 제거하고 갱신하는 데 이 리스트를 이용.
// 파티클을 그릴
준비가 완료되면
// 리스트 노드의 일부를 버텍스 버퍼로 복사하고
// 파티클 드로잉 과정을 거친다.
// 이어
다음 단계의 데이터를 복사하고 다시 파티클을 그리며,
// 모든 파티클을 그릴 때까지 이 과정을 반복.
int _maxParticles; // 주어진 시간 동안
시스템이 가질 수 있는 최대 파티클의 수.
// 예, 파티클이 파괴되는 속도보다 만들어지는 속도가 빠르다면
// 엄청나게
많은 수의 파티클이 동시에 존재할 수 있다.
// 이 멤버는 이와 같은 상황을 막는다.
DWORD _vbSize; // 버텍스 버퍼가 보관할 수 있는 파티클의 수.
// 이 값은 실제 파티클 시스템 내의 파티클 수와는 독립적.
DWORD _vbOffset; // 파티클 시스템의 렌더링에 이용.
DWORD _vbBatchSize; // 파티클 시스템의 렌더링에 이용.
};
// 눈
class Snow : public
PSystem
{
public:
// 생성자
// 경계 상자 구조체를
가리키는 포인터와 시스템 내 파티클의 수
// 경계 상자는 눈송이가 떨어질 부피를 정의하며,
// 만약 눈송이가 이 범위
밖으로 벗어 나면 즉시 소멸하고 다시 만들어짐.
// 항상 같은 수의 파티클을
유지.
Snow(d3d::BoundingBox* boundingBox, int numParticles);
void
resetParticle(Attribute* attribute);
void update(float
timeDelta);
};
// 불꽃놀이
class Firework : public
PSystem
{
public:
Firework(D3DXVECTOR3* origin, int
numParticles);
void resetParticle(Attribute* attribute);
void
update(float timeDelta);
void preRender();
void
postRender();
};
// 입자총
class ParticleGun : public
PSystem
{
public:
ParticleGun(Camera* camera);
void
resetParticle(Attribute* attribute);
void update(float
timeDelta);
private:
Camera* _camera;
};
}
#endif // __pSystemH__
//////////////////////////////////////////////////////////////////////////////////////////////////
//
// File: pSystem.cpp
//
// Author: Frank Luna (C) All Rights
Reserved
//
// System: AMD Athlon 1800+ XP, 512 DDR, Geforce 3, Windows
XP, MSVC++ 7.0
//
// Desc: Represents a geneal particle
system.
//
//////////////////////////////////////////////////////////////////////////////////////////////////
#include <cstdlib>
#include "pSystem.h"
using namespace psys;
const DWORD Particle::FVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;
// 초기화하는
생성자
PSystem::PSystem()
{
_device = 0;
_vb = 0; //버텍스 버퍼
_tex = 0; //텍스처
}
// 인터페이스 해제하는
디스트럭터
PSystem::~PSystem()
{
d3d::Release<IDirect3DVertexBuffer9*>(_vb);
d3d::Release<IDirect3DTexture9*>(_tex);
}
// init - 포인트 스프라이트를 저장하기 위한 버텍스 버퍼를 만들고
// 텍스처를 만드는
등의 Direct3D의 장치 의존적인 초기화 작업을 처리.
bool PSystem::init(IDirect3DDevice9*
device, char* texFileName)
{
// 우리는 동적 버텍스 버퍼를 이용할
것임.
// 매 프레임 마다 파티클을 갱신해야 하며 이는 곧 버텍스 버퍼의 메모리에 접근해야 함을 의미.
// 정적 버텍스
버퍼로의 접근 속도는 상당히 느리다는 데 주의.
// 동적 버텍스 버퍼를 이용하는 것은 바로 이
때문.
_device = device;
HRESULT hr = 0;
hr = device->CreateVertexBuffer(
// 버텍스 버퍼 크기가
_viSize에 의해 미리 정의되며
// 시스템 내의 파티클 수와는 관련이 없음을 주의.
_vbSize *
sizeof(Particle),
// 버텍스 버퍼가 포인트 스프라이트를 보관할 것임을 지정하는
D3DUSAGE_POINTS를 이용.
D3DUSAGE_DYNAMIC | D3DUSAGE_POINTS |
D3DUSAGE_WRITEONLY,
Particle::FVF,
// 동적 버텍스 버퍼는
관리 메모리 풀에 보관할 수 없으므로 디폴트 메모리 풀을 이용.
D3DPOOL_DEFAULT,
&_vb,
0);
if(FAILED(hr))
{
::MessageBox(0,
"CreateVertexBuffer() - FAILED", "PSystem", 0);
return false;
}
hr =
D3DXCreateTextureFromFile(
device,
texFileName,
&_tex);
if(FAILED(hr))
{
::MessageBox(0, "D3DXCreateTextureFromFile() -
FAILED", "PSystem", 0);
return false;
}
return true;
}
// 시스템 내의 모든 파티클 속성을 리셋.
void
PSystem::reset()
{
std::list<Attribute>::iterator i;
for(i =
_particles.begin(); i != _particles.end(); i++)
{
// 한 파티클의 속성을 리셋.
// 파티클의 속성이 리셋되는 방식은 파티클 시스템에 따라
달라짐.
// 따라서 하위 클래스에서 메서드를 구현하도록 추상 메서드로 선언.
resetParticle(
&(*i) );
}
}
// 시스템에 파티클을 추가.
// 이 메서드는 리스트에 추가 하기전에 파티클을 초기화 하는데
resetPaticle 메서드를 이용.
void PSystem::addParticle()
{
Attribute
attribute;
resetParticle(&attribute);
_particles.push_back(attribute);
}
// 포인트 스프라이트 렌더 상태.
void
PSystem::preRender()
{
_device->SetRenderState(D3DRS_LIGHTING,
false);
// 현재 지정된 전체 텍스처를 포인트 스프라이트의 텍스처 매핑에 이용할것임을
의미.
_device->SetRenderState(D3DRS_POINTSPRITEENABLE, true);
// 포인트 크기를 뷰 스페이스 단위로 해석하도록 지정.
// 뷰 스페이스 단위는 간단히
카메라 공간 내의 3D 포인트를 나타내며,
// 포인트 스프라이트의 크기는 카메라와의 거리에 따라 적절하게 조정됨.
// 즉,
카메라와 멀리 떨어진 파티클은 가까운 파티클에 비해작게
나타남.
_device->SetRenderState(D3DRS_POINTSCALEENABLE, true);
// 포인트 스프라이트의 크기를 지정.
// 이 값은 D3DRS_POINTSCALEENABLE
상태 값에 따라서 뷰 스페이스 내의 크기나
// 스크린 스페이스 내의 크기로 해석.
// FtoDw 함수는 float을
DWORD로 형 변환한다.
// 이 함수가 필요한 것은 일반적인 IDirect3DDevice9::SetRenderState
호출이
// float이 아닌 DWORD를 필요로 하기
때문.
_device->SetRenderState(D3DRS_POINTSIZE,
d3d::FtoDw(_size));
// 포인트 스프라이트의 지정할 수 있는 최소 크기를
지정.
_device->SetRenderState(D3DRS_POINTSIZE_MIN,
d3d::FtoDw(0.0f));
// 이 세 개의 상수는 거리에 따라 포인트 스프라이트의 크기가 변하는 방법을 제어.
//
여기에서 말하는 거리란 카메라와 포인트 스프라이트 간의
거리.
_device->SetRenderState(D3DRS_POINTSCALE_A,
d3d::FtoDw(0.0f));
_device->SetRenderState(D3DRS_POINTSCALE_B,
d3d::FtoDw(0.0f));
_device->SetRenderState(D3DRS_POINTSCALE_C,
d3d::FtoDw(1.0f));
// 텍스처의 알파를
이용.
_device->SetTextureStageState(0, D3DTSS_ALPHAARG1,
D3DTA_TEXTURE);
_device->SetTextureStageState(0, D3DTSS_ALPHAOP,
D3DTOP_SELECTARG1);
// 알파 블렌딩을 활성화하여 텍스처의 알파 채널이 텍스처의 픽셀 투명도를 결정하도록
했음.
// 이를 통해 다양한 효과를 얻을 수 있으며,
// 가장 대표적인 것이 사각형이 아닌 다른 파티클 형태를 구현 하는
것.
// 예, "눈덩이와 비슷한" 둥근 파티클을 얻기 위해서는
// 흰색의 원형과 검은색의 알파 채널을 갖는 흰색 텍스처를
이용하면 됨.
// 이렇게 하면 사각형의 흰색 텍스처 전체가아닌 흰색 원 모양의 파티클을 만들 수
있다.
_device->SetRenderState(D3DRS_ALPHABLENDENABLE,
true);
_device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
_device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
}
// 특정 파티클 시스템이 지정했을 수 있는 렌더 상태를 복구하는 데 이용.
// 이 메서드는
시스템에 따라 달라질 수 있으므로 가상 메서드로 선언.
void
PSystem::postRender()
{
_device->SetRenderState(D3DRS_LIGHTING,
true);
_device->SetRenderState(D3DRS_POINTSPRITEENABLE,
false);
_device->SetRenderState(D3DRS_POINTSCALEENABLE,
false);
_device->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
}
// 렌더링 메서드
void
PSystem::render()
{
//
// Remarks: The render method works by
filling a section of the vertex buffer with data,
// then we
render that section. While that section is rendering we lock a
new
// section and begin to fill that section. Once that sections
filled we render it.
// This process continues until all the
particles have been drawn. The benifit
// of this method is that
we keep the video card and the CPU busy.
if( !_particles.empty() )
{
//렌더 상태를
지정.
preRender();
_device->SetTexture(0,
_tex);
_device->SetFVF(Particle::FVF);
_device->SetStreamSource(0,
_vb, 0, sizeof(Particle));
// render batches one by one
//
// 버텍스 버퍼를 벗어날 경우 처음부터 시작한다.
// _vbOffset - 버텍스 버퍼에서 복사를 시작할 파티클 내 다음 단계로의 오프셋(바이트가 아닌 파티클
단위)
// 예, 단계 1이 0부터 499까지 항목이라면 단계 2로의 오프셋은 500이
된다.
if(_vbOffset >= _vbSize)
_vbOffset = 0;
Particle* v = 0;
// _vbBatchSize - 하나의 단계에 정의된 파티클의
수.
_vb->Lock(
_vbOffset * sizeof( Particle
),
_vbBatchSize * sizeof( Particle
),
(void**)&v,
_vbOffset ? D3DLOCK_NOOVERWRITE :
D3DLOCK_DISCARD);
DWORD numParticlesInBatch = 0;
// 모든 파티클이 렌더링될
때까지
//
std::list<Attribute>::iterator i;
for(i =
_particles.begin(); i != _particles.end(); i++)
{
if( i->_isAlive
)
{
// 한단계의 생존한 파티클을다음 버텍스 버퍼 세그먼트로
복사.
//
v->_position =
i->_position;
v->_color = (D3DCOLOR)i->_color;
v++; //
next element;
numParticlesInBatch++; //단계 카운터를 증가시킨다.
// 현재 단계가 모두 채워져
있는가?
if(numParticlesInBatch == _vbBatchSize)
{
//
// 버텍스 버퍼로 복사된 마지막 단계의 파티클들을
그린다.
//
_vb->Unlock();
_device->DrawPrimitive(
D3DPT_POINTLIST,
_vbOffset,
_vbBatchSize);
//
// 단계가 그려지는 동안 다음 단계를 파티클로
채운다.
//
// 다음 단계의 처음 오프셋으로 이동한다.
_vbOffset +=
_vbBatchSize;
// 버텍스 버퍼의 경계를 넘는메모리로 오프셋을 설정하지 않는다.
// 경계를
넘을 경우 처음부터 시작.
if(_vbOffset >= _vbSize)
_vbOffset =
0;
_vb->Lock(
_vbOffset * sizeof( Particle
),
_vbBatchSize * sizeof( Particle
),
(void**)&v,
_vbOffset ? D3DLOCK_NOOVERWRITE :
D3DLOCK_DISCARD);
numParticlesInBatch = 0; // 다음 단계를 위한
리셋
}
}
}
_vb->Unlock();
// (numParticlesInBatch == _vbBatchSize) 조건이
//
만족되지 못하여 마지막 단계가 렌더링되지 않는 경우가 발생할 수 있다.
// 일부만 채워진 단계는 바로 이곳에서 렌더링
된다.
if( numParticlesInBatch
)
{
_device->DrawPrimitive(
D3DPT_POINTLIST,
_vbOffset,
numParticlesInBatch);
}
// 다음 블록
_vbOffset += _vbBatchSize;
//
// reset render states
//
postRender();
}
}
// 현재 시스템에 파티클이 없는 경우 true 리턴.
bool
PSystem::isEmpty()
{
return _particles.empty();
}
// 시스템 내의 파티클이 모두 죽은 경우 true 리턴.
// 모든 파티클이 죽은 상태와
시스템이 빈 상태를 혼동하지 않도록.
// 빈 상태는 시스템 내에 파티클이 없는 상태를 의미
// 죽은 상태는 파티클이 존재하지만
죽은 것으로 표시된 상태를 의미.
bool
PSystem::isDead()
{
std::list<Attribute>::iterator i;
for(i =
_particles.begin(); i != _particles.end(); i++)
{
// is there at least
one living particle? If yes,
// the system is not dead.
if(
i->_isAlive )
return false;
}
// no living particles found, the
system must be dead.
return true;
}
// 속성 리스트 _particle을 검색하여 죽은 파티클을 리스트에서
제거.
void
PSystem::removeDeadParticles()
{
std::list<Attribute>::iterator
i;
i = _particles.begin();
while( i != _particles.end() )
{
if( i->_isAlive == false
)
{
// erase는 다음 반복자를 리턴하므로
// 우리가 반복자를
증가시킬 필요가 없다.
i = _particles.erase(i);
}
else
{
i++; // next in list
}
}
}
//*****************************************************************************
//
Snow System
//***************
// 생성자
// 경계 상자 구조체를 가리키는 포인터와 시스템 내 파티클의 수
//
경계 상자는 눈송이가 떨어질 부피를 정의하며,
// 만약 눈송이가 이 범위 밖으로 벗어 나면 즉시 소멸하고 다시
만들어짐.
// 항상 같은 수의 파티클을 유지.
Snow::Snow(d3d::BoundingBox*
boundingBox, int numParticles)
{
_boundingBox =
*boundingBox;
_size = 0.25f;
_vbSize = 2048; // 버텍스 버퍼의 크기
_vbOffset = 0; // 시작 오프셋
_vbBatchSize = 512;
for(int i =
0; i < numParticles; i++)
addParticle();
}
// 한 파티클의 속성을 리셋.
// 파티클의 속성이 리셋되는 방식은 파티클 시스템에 따라
달라짐.
// 따라서 하위 클래스에서 메서드를 구현하도록 추상 메서드로 선
// 경계 상자 내 임의의 x와 z좌표 위치에서 눈송이를 만들고
// y좌표를 경계 상자의
최상단과 같도록 지정.
// 이어 눈송이에 속도를 부여하여 아래 방향으로 그리고 약간 왼쪽으로 떨어지도록 한다.
// 눈송이는
흰색으로 표현.
void Snow::resetParticle(Attribute*
attribute)
{
attribute->_isAlive = true;
// GetRandomVector - 최소점 min과 최대점 max로 정의된 상자 내의 임의 벡터를
출력.
// 눈송이의 위치 지정을 위해 임의의 x, z 좌표를
얻는다.
d3d::GetRandomVector(
&attribute->_position,
&_boundingBox._min,
&_boundingBox._max);
// 높이 (y좌표) 는 항상 경계 상자의
최상단.
attribute->_position.y = _boundingBox._max.y;
// GetRandowFloat - [ lowBound, highBound ] 범위에 있는 임의의
float을 리턴.
// 눈송이는 아래쪽으로 떨어지며 약간 왼쪽을
향한다.
attribute->_velocity.x = d3d::GetRandomFloat(0.0f, 1.0f) *
-3.0f;
attribute->_velocity.y = d3d::GetRandomFloat(0.0f, 1.0f) *
-10.0f;
attribute->_velocity.z = 0.0f;
// 흰색의 눈송이
attribute->_color =
d3d::WHITE;
}
// 시스템 내의 모든 파티클들을 갱신.
// 메서드의 구현은 특정 파티클 시스템에 따라
달라지므로
// 하위 클래스에서 메서드를 구현하도록 추상 메서드로 선언.
// 파티클의 위치를 갱신하며
// 시스템의 경계 상자를 벗어났는지 확인.
// 만약
경계 상자를 벗어났다면 해당 파티클을 초기화.
void Snow::update(float
timeDelta)
{
std::list<Attribute>::iterator i;
for(i =
_particles.begin(); i != _particles.end(); i++)
{
i->_position +=
i->_velocity * timeDelta;
// 포인트가 경계를 벗어났는가?
if(
_boundingBox.isPointInside( i->_position ) == false )
{
// 경계를 벗어난 파티클을 재활용.
resetParticle( &(*i)
);
}
}
}
//*****************************************************************************
//
Explosion System
//********************
// 불꽃놀이 생성자
// 시스템 원천(불꽃이 폭발할 장소) 으로의 포인터, 시스템이 가진
파티클의 수.
Firework::Firework(D3DXVECTOR3* origin, int
numParticles)
{
_origin = *origin;
_size =
0.9f;
_vbSize = 2048;
_vbOffset = 0;
_vbBatchSize =
512;
for(int i = 0; i < numParticles; i++)
addParticle();
}
// 시스템 원천의 파티클을 초기화하고 구체 내에서 임의의 속도를 만들며,
// 시스템 내의
파티클들은 임의의 컬러를 부여.
// 각 파티클들이 2초 동안 유지하도록 수명을 지정.
void
Firework::resetParticle(Attribute* attribute)
{
attribute->_isAlive =
true;
attribute->_position = _origin;
D3DXVECTOR3 min = D3DXVECTOR3(-1.0f, -1.0f, -1.0f);
D3DXVECTOR3 max =
D3DXVECTOR3( 1.0f, 1.0f, 1.0f);
d3d::GetRandomVector(
&attribute->_velocity,
&min,
&max);
// 구체를 만들기 위한
정규화
D3DXVec3Normalize(
&attribute->_velocity,
&attribute->_velocity);
attribute->_velocity *= 100.0f;
attribute->_color = D3DXCOLOR(
d3d::GetRandomFloat(0.0f,
1.0f),
d3d::GetRandomFloat(0.0f, 1.0f),
d3d::GetRandomFloat(0.0f,
1.0f),
1.0f);
attribute->_age = 0.0f;
attribute->_lifeTime = 2.0f; // 2초 동안의 수명을 가진다.
}
// 각 파티클의 위치를 갱신하고 수명을 초과한파티클의 죽음을 처리.
// 이 시스템은 죽은
파티클을 제거하지 않는다.
// 이것은 새로운 불꽃을 만들 때 기존의 죽은 Firework 시스템을 재활용할 수 있기 때문.
//
즉, 파티클을 만들고 제거하는 번거로운 과정을 최소화.
void Firework::update(float
timeDelta)
{
std::list<Attribute>::iterator i;
for(i = _particles.begin(); i != _particles.end(); i++)
{
// 생존한 파티클만 갱신.
if( i->_isAlive
)
{
i->_position += i->_velocity * timeDelta;
i->_age += timeDelta;
if(i->_age > i->_lifeTime) //
죽인다.
i->_isAlive = false;
}
}
}
// 렌더링에 앞서 지정해야 할 초기 렌더 상태를 지정.
// 이 메서드는 시스템에 따라 달라질
수 있으므로 가상 함수로 선언.
// 다른 블렌드 인수가 이용.
// 깊이 버퍼로의 쓰기도 허용되지 않음.
// 디폴트
블렌드 인수와 쓰기 여부를 변경하고자 한다면
// pSystem::preRender와 pSystem::postRender 메서드를
오버라이드하면 됨.
void
Firework::preRender()
{
PSystem::preRender(); // 부모
버전의 메서드를 호출.
_device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
_device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
// z 버퍼 읽기는 가능 하지만 쓰기는 허용하지
않는다.
_device->SetRenderState(D3DRS_ZWRITEENABLE, false);
}
void Firework::postRender()
{
PSystem::postRender();
_device->SetRenderState(D3DRS_ZWRITEENABLE, true);
}
//*****************************************************************************
//
Laser System
//****************
// 입자총 생성자
// 카메라로의 포인터를 받는다.
// 새로운 파티클을 만들 때마다 카메라의 위치와 방향에 대한
정보가 필요.
ParticleGun::ParticleGun(Camera*
camera)
{
_camera = camera;
_size =
0.8f;
_vbSize = 2048;
_vbOffset = 0;
_vbBatchSize = 512;
}
// 파티클의 위치를 카메라의 현재 위치로 지정하고
// 파티클의 속도를 카메라가 보고 있는
방향의 100배로 지정.
// 이 같은 방법으로 현재 바라보고 있는 방향으로 "총알"을 발사할 수 있다.
// 파티클의 컬러는
녹색으로 지정.
void ParticleGun::resetParticle(Attribute*
attribute)
{
attribute->_isAlive = true;
D3DXVECTOR3 cameraPos;
_camera->getPosition(&cameraPos);
D3DXVECTOR3 cameraDir;
_camera->getLook(&cameraDir);
// 파티클 위치에 카메라 위치를 이용.
attribute->_position
= cameraPos;
attribute->_position.y -= 1.0f; // 카메라보다
약간 아래쪽으로 이동해
// 총을 들고 있는 것 같은 효과를 얻는다.
// 카메라가 바라보는 방향으로
발사한다.
attribute->_velocity = cameraDir * 100.0f;
// 녹색
attribute->_color = D3DXCOLOR(0.0f,
1.0f, 0.0f, 1.0f);
attribute->_age = 0.0f;
attribute->_lifeTime = 1.0f; // 수명은 1초
}
// 파티클의 위치를 갱신하고
// 수명이 다한 경우 죽은 것으로 처리한다.
// 파티클
리스트를 검색하여 죽은 파티클을 제거.
void ParticleGun::update(float
timeDelta)
{
std::list<Attribute>::iterator i;
for(i = _particles.begin(); i != _particles.end();
i++)
{
i->_position += i->_velocity * timeDelta;
i->_age += timeDelta;
if(i->_age > i->_lifeTime) // kill
i->_isAlive =
false;
}
removeDeadParticles();
}
x파일에 대한 문서.pdf
DXViewer.exe
이다.
