animatedsprite.cpp
No OneTemporary
Actions

Authored By

Unknown

Size

5 KB

Referenced Files

None

Subscribers

None

animatedsprite.cpp
View Options

	////////////////////////////////////////////////////////////
	//
	// Copyright (C) 2014 Maximilian Wagenbach (aka. Foaly) (foaly.f@web.de)
	//
	// This software is provided 'as-is', without any express or implied warranty.
	// In no event will the authors be held liable for any damages arising from the use of this software.
	//
	// Permission is granted to anyone to use this software for any purpose,
	// including commercial applications, and to alter it and redistribute it freely,
	// subject to the following restrictions:
	//
	// 1. The origin of this software must not be misrepresented;
	// you must not claim that you wrote the original software.
	// If you use this software in a product, an acknowledgment
	// in the product documentation would be appreciated but is not required.
	//
	// 2. Altered source versions must be plainly marked as such,
	// and must not be misrepresented as being the original software.
	//
	// 3. This notice may not be removed or altered from any source distribution.
	//
	////////////////////////////////////////////////////////////

	// This file has been created using Maximilian Wagenbach (aka. Foaly) sources
	// further modificated. Thank you Foaly.

	#include "animatedsprite.h"
	#include <cmath>

	AnimatedSprite::AnimatedSprite(sf::Time frameTime, bool paused, bool looped) :
	m_animation(NULL), m_frameTime(frameTime), m_currentFrame(0), m_isPaused(paused), m_isLooped(looped), m_texture(NULL)
	{

	// setScale(1.9,1.9);

	setFrameTime(sf::seconds(0.5f));
	setFrameTime(sf::seconds(0.5f));
	}

	void AnimatedSprite::setAnimation(const Animation& animation)
	{
	m_animation = &animation;
	m_texture = m_animation->getSpriteSheet();
	m_currentFrame = 0;
	setFrame(m_currentFrame);
	}

	void AnimatedSprite::setFrameTime(sf::Time time)
	{
	m_frameTime = time;
	}

	void AnimatedSprite::play()
	{
	m_isPaused = false;
	}

	void AnimatedSprite::play(const Animation& animation)
	{
	if (getAnimation() != &animation)
	setAnimation(animation);
	play();
	}

	void AnimatedSprite::pause()
	{
	m_isPaused = true;
	}

	void AnimatedSprite::stop()
	{
	m_isPaused = true;
	m_currentFrame = 0;
	setFrame(m_currentFrame);
	}

	void AnimatedSprite::setLooped(bool looped)
	{
	m_isLooped = looped;
	}

	void AnimatedSprite::setColor(const sf::Color& color)
	{
	// Update the vertices' color
	m_vertices[0].color = color;
	m_vertices[1].color = color;
	m_vertices[2].color = color;
	m_vertices[3].color = color;
	}

	const Animation* AnimatedSprite::getAnimation() const
	{
	return m_animation;
	}

	sf::FloatRect AnimatedSprite::getLocalBounds() const
	{
	sf::IntRect rect = m_animation->getFrame(m_currentFrame);

	float width = static_cast<float>(std::fabs(rect.width));
	float height = static_cast<float>(std::fabs(rect.height));

	return sf::FloatRect(0.f, 0.f, width, height);
	}

	sf::FloatRect AnimatedSprite::getGlobalBounds() const
	{
	return getTransform().transformRect(getLocalBounds());
	}

	bool AnimatedSprite::isLooped() const
	{
	return m_isLooped;
	}

	bool AnimatedSprite::isPlaying() const
	{
	return !m_isPaused;
	}

	sf::Time AnimatedSprite::getFrameTime() const
	{
	return m_frameTime;
	}

	void AnimatedSprite::setFrame(std::size_t newFrame, bool resetTime)
	{
	if (m_animation)
	{
	//calculate new vertex positions and texture coordiantes
	sf::IntRect rect = m_animation->getFrame(newFrame);

	m_vertices[0].position = sf::Vector2f(0.f, 0.f);
	m_vertices[1].position = sf::Vector2f(0.f, static_cast<float>(rect.height));
	m_vertices[2].position = sf::Vector2f(static_cast<float>(rect.width), static_cast<float>(rect.height));
	m_vertices[3].position = sf::Vector2f(static_cast<float>(rect.width), 0.f);

	float left = static_cast<float>(rect.left) + 0.0001f;
	float right = left + static_cast<float>(rect.width);
	float top = static_cast<float>(rect.top);
	float bottom = top + static_cast<float>(rect.height);

	m_vertices[0].texCoords = sf::Vector2f(left, top);
	m_vertices[1].texCoords = sf::Vector2f(left, bottom);
	m_vertices[2].texCoords = sf::Vector2f(right, bottom);
	m_vertices[3].texCoords = sf::Vector2f(right, top);
	}

	if (resetTime)
	m_currentTime = sf::Time::Zero;
	}

	void AnimatedSprite::update(sf::Time deltaTime)
	{
	// if not paused and we have a valid animation
	if (!m_isPaused && m_animation)
	{
	// add delta time
	m_currentTime += deltaTime;

	// if current time is bigger then the frame time advance one frame
	if (m_currentTime >= m_frameTime)
	{
	// reset time, but keep the remainder
	m_currentTime = sf::microseconds(m_currentTime.asMicroseconds() % m_frameTime.asMicroseconds());

	// get next Frame index
	if (m_currentFrame == 0)
	m_currentFrame++;
	else
	{
	// animation has ended
	m_currentFrame = 0; // reset to start

	if (!m_isLooped)
	{
	m_isPaused = true;
	}

	}

	// set the current frame, not reseting the time
	setFrame(m_currentFrame, false);
	}
	}
	}

	void AnimatedSprite::draw(sf::RenderTarget& target, sf::RenderStates states) const
	{
	if (m_animation && m_texture)
	{
	states.transform *= getTransform();
	states.texture = m_texture;
	target.draw(m_vertices, 4, sf::Quads, states);
	}
	}

File Metadata

Mime Type: text/x-c
Expires: Sun, Aug 16, 12:53 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 77348
Default Alt Text: animatedsprite.cpp (5 KB)

animatedsprite.cppNo OneTemporaryActions

animatedsprite.cppView Options

File Metadata

Event Timeline

animatedsprite.cpp
No OneTemporary
Actions

animatedsprite.cpp
View Options