SFML-Animation-3.0/AnimationManager.cpp at main · allenmonkey970/SFML-Animation-3.0 · GitHub

History

130 lines (113 loc) · 5.9 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

#include "AnimationManager.h"

#include <iostream>

// This implementation file provides the definitions for the member functions declared

// in the AnimationManager class. The key functionalities implemented include:

// - update: Updates the animation frame for a specific sprite based on the animation's frequency.

// - updateAll: Updates all animations in a given map of sprites.

// - addAnimation: Adds a new animation with specified parameters (texture, sheet size, sprite size, etc.).

// - deleteAnimation: Deletes an existing animation.

// - Setters: Modify animation properties such as frequency, sprite size, sheet size, and indices.

// The file initializes the static member variables and provides the logic for updating and managing

// animations in a game. Error handling and frequency-based updates are also implemented to ensure

// smooth animation transitions.

// Initialize static member variables

std::map<std::string, sf::Texture> AnimationManager::m_textures;

std::map<std::string, sf::Vector2i> AnimationManager::m_indices;

std::map<std::string, sf::Vector2i> AnimationManager::m_startingIndices;

std::map<std::string, sf::Vector2i> AnimationManager::m_endingIndices;

std::map<std::string, sf::Vector2i> AnimationManager::m_sheetSizes;

std::map<std::string, sf::Vector2i> AnimationManager::m_spriteSizes;

std::map<std::string, int> AnimationManager::m_frequencies;

std::map<std::string, int> AnimationManager::m_timesUpdated;

void AnimationManager::update(const std::string &animation, sf::Sprite &sprite) {

// Check if the animation sheet size is valid

if (m_sheetSizes[animation] != sf::Vector2i(0, 0)) {

// Increment the update counter and check if it meets the frequency condition

if (++m_timesUpdated[animation] >= m_frequencies[animation]) {

m_timesUpdated[animation] = 0; // Reset the update counter

// Calculate the texture rectangle for the current frame

sf::IntRect rect({

m_indices[animation].x * m_spriteSizes[animation].x,

m_indices[animation].y * m_spriteSizes[animation].y

{m_spriteSizes[animation].x, m_spriteSizes[animation].y});

// Set the sprite texture and texture rectangle

sprite.setTexture(m_textures[animation]);

sprite.setTextureRect(rect);

// Update the animation indices to the next frame

if (m_indices[animation].y < m_sheetSizes[animation].y - 1) {

++m_indices[animation].y;

} else if (m_indices[animation].x < m_sheetSizes[animation].x - 1) {

m_indices[animation].y = 0;

++m_indices[animation].x;

} else {

m_indices[animation] = m_startingIndices[animation]; // Reset to starting index for looping animation

}

} else {

// Output an error message if no animation entry is found

std::cerr << "No animation entry found for \"" << animation << "\"!" << std::endl;

}

void AnimationManager::updateAll(std::map<std::string, sf::Sprite> &map) {

// Iterate through the map and update each animation

for (auto &element: map) {

update(element.first, element.second);

}

void AnimationManager::addAnimation(const std::string &animation, const sf::Texture &texture,

sf::Vector2i sheetSize, sf::Vector2i spriteSize,

sf::Vector2i index, int frequency,

sf::Vector2i startingIndex) {

// Add a new animation with the specified parameters

m_textures[animation] = texture;

m_sheetSizes[animation] = sheetSize;

m_spriteSizes[animation] = spriteSize;

m_indices[animation] = index;

m_startingIndices[animation] = startingIndex;

m_endingIndices[animation] = sheetSize;

m_frequencies[animation] = frequency;

m_timesUpdated[animation] = 0; // Initialize the times updated counter

}

void AnimationManager::deleteAnimation(const std::string &animation) {

// Remove the animation entry from all maps

m_textures.erase(animation);

m_indices.erase(animation);

m_startingIndices.erase(animation);

m_endingIndices.erase(animation);

m_sheetSizes.erase(animation);

m_spriteSizes.erase(animation);

m_frequencies.erase(animation);

m_timesUpdated.erase(animation);

}

void AnimationManager::setAnimationFrequency(const std::string &animation, int frequency) {

// Set the update frequency for the specified animation

m_frequencies[animation] = frequency;

}

void AnimationManager::setAnimationSpriteSize(const std::string &animation, sf::Vector2i size) {

// Set the sprite size for the specified animation

m_spriteSizes[animation] = size;

}

void AnimationManager::setAnimationSheetSize(const std::string &animation, sf::Vector2i size) {

// Set the sheet size for the specified animation

m_sheetSizes[animation] = size;

}

void AnimationManager::setAnimationIndex(const std::string &animation, sf::Vector2i index) {

// Set the current index for the specified animation

m_indices[animation] = index;

}

void AnimationManager::setAnimationTexture(const std::string &animation, const sf::Texture &texture) {

// Set the texture for the specified animation

m_textures[animation] = texture;

}

void AnimationManager::resetAnimationIndex(const std::string &animation) {

// Reset the current index to the starting index for the specified animation

m_indices[animation] = m_startingIndices[animation];

}

void AnimationManager::setAnimationStartingIndex(const std::string &animation, sf::Vector2i index) {

// Set the starting index for the specified animation

m_startingIndices[animation] = index;

}

void AnimationManager::setAnimationEndingIndex(const std::string &animation, sf::Vector2i index) {

// Set the ending index for the specified animation

m_endingIndices[animation] = index

SFML-Animation-3.0/AnimationManager.cpp at main · allenmonkey970/SFML-Animation-3.0 · GitHub

Expand file tree

Breadcrumbs

AnimationManager.cpp

Latest commit

History

Breadcrumbs

AnimationManager.cpp

File metadata and controls