Au sinon j'ai vu que la position était stockée dans la classe sf::Transformable et non dans la classe sf::Sprite comme je le pensais et ce qui me semblerait plus logique. (Du coup je me retrouve avec 2 positions (celle su sprite et celle du noeud (ma classe Tile).)
Je pense plus tard que je vais utiliser mes propres classes de transformation plutôt que la sfml et faire les transformation directement sur des vertexarray avant d'appeler draw. (Commele font la plupart des framework, je pense même que la plupart des framewors n'utilisent même plus le matrices d'opengl.)
Parce que là je dois réimplémenter toute les méthodes de la classe Transformable. (Je préfère ça que d'utiliser un sf::Transform et de devoir réimplémenter toutes les méthodes setRotation, setScale, etc... si ce n'est pas nécessaire.) de sorte à ce que Transformabe contienne juste les transformations et l'origine, combiner mes transformations avec celle du sprite qui ne contient que la position et l'origine finalement.
Avec l'origine je suis un peu perdu aussi car j'ai 2 origines, celles du sprite et celles de la classe transformable, bref, je mets les 2 mêmes origines pour les 2.
Bref en gros voilà ce que j'ai fais :
#ifndef TILE
#define TILE
#include <SFML/Graphics.hpp>
#include "../Math/vec4.h"
#include "../Math/maths.h"
#include "../Lighting/light.h"
#include "../Math/computer.h"
#include <vector>
class MyCanvas;
class GridMap;
class Shadow;
class Wall;
class Tile : public Entity, public sf::Drawable , public sf::Transformable {
public :
//Type principale de la couche.
Tile (sf::Texture &image, Vec2f position, Vec2f size, sf::IntRect subRect, bool bToAnim);
sf::Sprite& getSprite ();
const sf::Texture& getTexture ();
Vec2f getSize();
virtual Vec2f getPosition();
Vec2f getCenter();
void setZOrder(int zOrder);
virtual void setPosition (Vec2f pos);
void setCenter(Vec2f center);
void setSize(Vec2f size);
virtual void setOrigin(Vec2f origin);
sf::IntRect getTextRect();
void setAltitude (int altitude);
int getAltitude ();
bool operator== (Tile &tile);
bool operator!= (Tile &tile);
int getZOrder();
void setSelected(bool selected);
bool isSelected ();
void setShadowCenter(int cx, int cy);
Vec2f getShadowCenter ();
bool belongToAnim ();
void popup();
void popback ();
virtual ~Tile ();
private :
virtual void draw(sf::RenderTarget &target, sf::RenderStates states) const;
Tile (const Tile* tile);
int zOrder;
bool selected, bToAnim;
sf::Sprite sprite;
};
#endif
#include "tile.h"
#include "../world/gridMap.h"
#include "../Lighting/shadow.h"
#include "../Lighting/wall.h"
using namespace sf;
using namespace std;
/*Gère les différents tiles, cette classe hérite de Sprite.
*/
//Crée un tile, avec une image passée en paramètre.
Tile::Tile (sf::Texture &image, Vec2f position, Vec2f size, IntRect subRect, bool bToAnim) : Entity (E_TILE) {
sprite.setTexture(image);
sprite.setTextureRect(subRect);
float factorX = size.x / subRect.width;
float factorY = size.y / subRect.height;
sprite.setOrigin(subRect.width * 0.5f, subRect.height * 0.5f);
sprite.scale(factorX, factorY);
sprite.setPosition(position.x + size.x * 0.5f, position.y + size.y * 0.5f);
this->bToAnim = bToAnim;
zOrder = 0;
selected = false;
Transformable::setOrigin(subRect.width * 0.5f, subRect.height * 0.5f);
}
void Tile::setOrigin(Vec2f origin) {
Transformable::setOrigin(origin.x, origin.y);
sprite.setOrigin(origin.x, origin.y);
}
IntRect Tile::getTextRect () {
return sprite.getTextureRect();
}
Vec2f Tile::getSize() {
Vec2f size(sprite.getGlobalBounds().width, sprite.getGlobalBounds().height);
return size;
}
void Tile::setSize(Vec2f size) {
Vec2f actualSize = this->getSize();
Vec2f scale = size / actualSize;
this->size = size;
sprite.setScale(scale.x, scale.y);
}
const Texture& Tile::getTexture () {
return *sprite.getTexture();
}
Vec2f Tile::getCenter () {
return Vec2f(sprite.getPosition().x, sprite.getPosition().y);
}
Vec2f Tile::getPosition() {
return Vec2f(sprite.getGlobalBounds().left, sprite.getGlobalBounds().top);
}
bool Tile::belongToAnim () {
return bToAnim;
}
void Tile::popup () {
if (zOrder + 1 <= DEFAULT_SHADOW_Z_ORDER)
zOrder++;
}
void Tile::popback () {
if (zOrder - 1 >= 0)
zOrder--;
}
bool Tile::operator== (Tile &tile) {
return sprite.getTexture() == tile.sprite.getTexture() &&
sprite.getPosition().x == tile.sprite.getPosition().x &&
sprite.getPosition().y == tile.sprite.getPosition().y &&
getSize().x == tile.getSize().x &&
getSize().y == tile.getSize().y &&
getZOrder() == tile.getZOrder() &&
getType() == tile.getType () &&
sprite.getTextureRect().left == tile.sprite.getTextureRect().left &&
sprite.getTextureRect().top == tile.sprite.getTextureRect().top &&
sprite.getTextureRect().height == tile.sprite.getTextureRect().height &&
sprite.getTextureRect().width == tile.sprite.getTextureRect().width;
}
bool Tile::operator!= (Tile &tile) {
return !(*this == tile);
}
//Getter.
Sprite& Tile::getSprite () {
return sprite;
}
//Renvoie le numéro de la couche du sprite.
int Tile::getZOrder() {
return zOrder;
}
bool Tile::isSelected () {
return selected;
}
void Tile::setZOrder(int zOrder) {
this->zOrder = zOrder;
}
void Tile::setSelected (bool selected) {
this->selected = selected;
}
void Tile::setPosition(Vec2f pos) {
Vec2f origin (sprite.getOrigin().x, sprite.getOrigin().y);
Vec2f originalSize (sprite.getTextureRect().width, sprite.getTextureRect().height);
Vec2f size = getSize();
Vec2f scale (size.x / originalSize.x, size.y / originalSize.y);
Vec2f sub (origin.x * scale.x, origin.y * scale.y);
sprite.setPosition(Vec2f(sprite.getPosition().x - sub.x, sprite.getPosition().y - sub.y));
}
void Tile::setCenter(Vec2f center) {
sprite.setPosition(Vector2f(center.x, center.y));
}
void Tile::draw (RenderTarget &target, RenderStates states) const {
states.transform = states.transform * getTransform();
target.draw(sprite, states);
}
Tile::~Tile () {
}
Un peu compliqué je pense que y'a peut être moyen de faire plus simple. :/
Donc finalement qu'est ce qui est mieux, faire des transformations sur des vertex en utilisant ses propres matrices ou alors faire des transformation sur des vertex en utilisant les matrices d'opengl ?
Je pencherai plutôt pour la 1ère solution moi.
