Animator

예제 :)

https://github.com/eazuooz/WindowAPI/commit/ba073f8950369851aa3b812bf7ed862141d52784

Animation Event · eazuooz/WindowAPI@ba073f8

2D 게임에서 애니메이션을 재생시키는 방법은 영화에서 쓰이는 방식과 크게 다르지 않다.

이러한 애니메이션 기법을 Sprite 애니메이션이라고 한다.

 

이러한 그림을 한장장한을 움직이는 순서대로 빠른시간동안 재생시켜주면 눈의 착시로 움직이는 것 처럼 보이게 된다.

 

우선은 Animation이 재생되게 하는 Animator 컴포넌트와 

Animator 컴포넌트는 Animation 을 가지고 있다.

	class Animator : public Component
	{
	public:
		struct Event
		{
			void operator=(std::function<void()> func)
			{
				mEvent = std::move(func);
			}
			void operator()()
			{
				if (mEvent)
					mEvent();
			}
			std::function<void()> mEvent;
		};

	public:
		Animator();
		~Animator();

		virtual void Tick() override;
		virtual void Render(HDC hdc) override;

		void CreateAnimaiton(const std::wstring& name, Image* image
			, Vector2 leftTop, Vector2 size, Vector2 offset
			, float columnLegth, UINT spriteLength, float duration, bool bAffectedCamera = false);
		Animation* FindAnimation(const std::wstring& name);
		void Play(const std::wstring& name, bool bLoop = false);

	public:
		Event mStartEvent;
		Event mCompleteEvent;
		Event mEndEvent;

	private:
		std::map<std::wstring, Animation*> mAnimations;
		Animation* mPlayAnimation;
		bool mbLoop;
	};

	typedef std::map<std::wstring, Animation*>::iterator AnimationsIter;

Animator 컴포넌트는 여러개의 Animation 들 (예 : 달리기, 걷기, 대기, 죽는 모션 등) 을 가지고 있게 된다.

그리고 현재 실행되는 애니메이션은 PlayAnimation이다.

Loop가 활성화 되어있다면 해당 애니메이션은 종료되지 않고 

다시 Reset() 시켜서 처음부터 다시 재생되게 된다.

 

	void Animator::Tick()
	{
		if (mPlayAnimation != nullptr)
		{
			mPlayAnimation->Tick();
			if (mbLoop && mPlayAnimation->isComplete())
			{
				mCompleteEvent();
				mPlayAnimation->Reset();
			}
		}
	}

 

Event는 각각의 애니메이션이 처음 재생될떄 StartEvent

하나의 애니메이션 동작이 완료될떄 CompleteEvent

애니메이션이 전환되면서 끝날때 EndEvent함수를 호출되게 되어있다.

 

그래서 다음과 같이 Event에 알맞는 멤버함수를 bind시켜주어야 제대로 동작하게 된다.

		Image* pImage
			= Resources::Load<Image>(L"PlayerImage", L"..\\Resources\\Images\\link.bmp");
		Animator* animator = GetComponent<Animator>();
		animator->CreateAnimaiton(L"Walk_Up", pImage, Vector2(0.f, 780.f), Vector2(120.f, 130.f), Vector2(0.f, -30.f), 120.f, 10, 0.1f);
		animator->CreateAnimaiton(L"Walk_Down", pImage, Vector2(0.f, 520.f), Vector2(120.f, 130.f), Vector2(0.f, -30.f), 120.f, 10, 0.1f);
		animator->CreateAnimaiton(L"Walk_Left", pImage, Vector2(0.f, 650.f), Vector2(120.f, 130.f), Vector2(0.f, -30.f), 120.f, 10, 0.1f);
		animator->CreateAnimaiton(L"Walk_Right", pImage, Vector2(0.f, 910.f), Vector2(120.f, 130.f), Vector2(0.f, -30.f), 120.f, 10, 0.1f);

		animator->mStartEvent = std::bind(&Player::AnimationStart, this);
		animator->mCompleteEvent = std::bind(&Player::AnimationComplete, this);
		animator->mEndEvent = std::bind(&Player::AnimationEnd, this);

		animator->Play(L"Walk_Down", true);

해당 Event들은 여러분들의 편리성을 위해 제공한것이다.

 

각각의 Event가 호출되는 순서는 다음과 같이 호출된다고 보면 된다.

 

애니메이션 클래스는 다음과 같이 구성되어 있다.

	class Image;
	class Animator;
	class Animation : public Entity
	{
	public:
		struct Sprite
		{
			Vector2 leftTop;	// 좌측 상단 픽셀좌표
			Vector2 size;		// 좌측 상단으로 부터 잘라낼 가로 세로 픽셀 길이
			Vector2 offset;
			float duration;			// 해당 프레임 유지시간

			Sprite()
				: leftTop(0.0f, 0.0f)
				, size(0.0f, 0.0f)
				, offset(0.0f, 0.0f)
				, duration(0.0f)
			{

			}
		};

	public:
		Animation();
		~Animation();
		
		void Tick();
		void Render(HDC hdc);
		void Create(Image* image, Vector2 leftTop, Vector2 size, Vector2 offset
			, float columnLegth, UINT spriteLength, float duration, bool affectedCamera = false);

		void Reset();

		bool isComplete() { return mbComplete; }
		void SetAnimator(Animator* animator) { mAnimator = animator; }

	private:
		Animator* mAnimator;
		Image* mImage;
		std::vector<Sprite> mSpriteSheet;
		int mSpriteIndex;
		float mTime;
		bool mbComplete;
		bool mbAffectedCamera;
	};

 

Animation 클래스는 Sprite Image를 가지고 있다.

여러개의 Sprite 가 모여서 하나의 Sprite sheet가 되고 그것이 하나의 애니메이션 정보라고 보면 된다.

 

애니메이션을 생성할때 해당 이미지에서 시작점을 기준으로 한칸씩 이동하면서 그림별로 Sprite정보를 Spritesheet에다가 저장한다.

	void Animation::Create(Image* image, Vector2 leftTop, Vector2 size, Vector2 offset
		, float columnLegth, UINT spriteLength, float duration, bool affectedCamera)
	{
		mImage = image;
		mbAffectedCamera = affectedCamera;

		for (size_t i = 0; i < spriteLength; i++)
		{
			Sprite sprite;

			sprite.leftTop.x = leftTop.x + (columnLegth * float(i));
			sprite.leftTop.y = leftTop.y;
			sprite.size = size;
			sprite.offset = offset;
			sprite.duration= duration;

			mSpriteSheet.push_back(sprite);
		}
	}
    
    	void Animation::Tick()
	{
		if (mbComplete)
			return;

		mTime += Time::DeltaTime();
		if (mSpriteSheet[mSpriteIndex].duration < mTime)
		{
			mTime = 0.0f;

			if (mSpriteSheet.size() <= mSpriteIndex + 1)
			{
				mbComplete = true;
			}
			else
			{
				mSpriteIndex += 1;
			}
		}
	}
    
    	void Animation::Render(HDC hdc)
	{
		Object* object = mAnimator->GetOwner();
		Vector2 pos = object->GetPos();
		if (mbAffectedCamera)
			pos = Camera::CalulatePos(pos);

		BLENDFUNCTION func = {};
		func.BlendOp = AC_SRC_OVER;
		func.BlendFlags = 0;
		func.AlphaFormat = AC_SRC_ALPHA;
		func.SourceConstantAlpha = 255;

		pos += mSpriteSheet[mSpriteIndex].offset;
		AlphaBlend(hdc
			, int(pos.x - mSpriteSheet[mSpriteIndex].size.x / 2.0f)
			, int(pos.y - mSpriteSheet[mSpriteIndex].size.y / 2.0f)
			, int(mSpriteSheet[mSpriteIndex].size.x)
			, int(mSpriteSheet[mSpriteIndex].size.y)
			, mImage->GetHdc()
			, int(mSpriteSheet[mSpriteIndex].leftTop.x)
			, int(mSpriteSheet[mSpriteIndex].leftTop.y)
			, int(mSpriteSheet[mSpriteIndex].size.x)
			, int(mSpriteSheet[mSpriteIndex].size.y)
			, func);
	}

재생할때는 각각의 프레임마다 재생시간을 계산한후  sprite를 하나씩 재생하면된다.