Bonjour à tous !

Je code en ce moment un générateur de particules après avoir lu le tuto de Once en m'efforçant de le faire orienté objet avec OpenGL et la SFML, et j'ai un problème :

Voici mon code :

Particle.hpp

#ifndef DEF_PARTICLES
#define DEF_PARTICLES

#include <SFML/Graphics.hpp>
#include <GL/gl.h>
#include <GL/glu.h>
#include <iostream>
#include <vector>

class Particle
{
    public :

    Particle();

    void SetPosition(double x, double y, double z);
    void SetSize(double size);
    void SetActive(bool active);
    void SetFade(double fade);
    void SetLife(double life);
    void SetColor(double r, double g, double b);
    void SetMove(double xi, double yi, double zi);
    void SetGravity(double xg, double yg, double zg);

    double GetPosX();
    double GetPosY();
    double GetPosZ();
    bool GetActive();
    double GetLife();
    double GetFade();
    double GetColorR();
    double GetColorG();
    double GetColorB();
    double GetMoveX();
    double GetMoveY();
    double GetMoveZ();
    double GetGravityX();
    double GetGravityY();
    double GetGravityZ();
    double GetSize();

    protected :

    bool m_active; // Active
    float m_life; // Durée de vie
    float m_fade; // Vitesse de disparition
    float m_r, m_g, m_b; // Valeurs RGB pour la couleur
    float m_x, m_y, m_z; // Position
    float m_xi, m_yi, m_zi; // Vecteur de déplacement
    float m_xg, m_yg, m_zg; // Gravité
    float m_size;
};

int initParticles(std::vector<Particle>&);
int dessinerParticules(std::vector<Particle>&, bool, float, float, float);

float myRand(float, float);

#endif

Particle.cpp :

#include "Particle.hpp"

float myRand(float min, float max)
{
    return sf::Randomizer::Random(min, max);
}

Particle::Particle() :
                   m_x(0), m_y(0), m_z(0),
                   m_fade(0),
                   m_r(0), m_g(0), m_b(0),
                   m_xi(0), m_yi(0), m_zi(0),
                   m_xg(0), m_yg(0), m_zg(0),
                   m_life(1),
                   m_active(true),
                   m_size(0.5)
{
}

void Particle::SetPosition(double x, double y, double z)
{
    m_x = x;
    m_y = y;
    m_z = z;
}

void Particle::SetColor(double r, double g, double b)
{
    m_r = r;
    m_g = g;
    m_b = b;
}

void Particle::SetMove(double xi, double yi, double zi)
{
    m_xi = xi;
    m_yi = yi;
    m_zi = zi;
}

void Particle::SetGravity(double xg, double yg, double zg)
{
    m_xg = xg;
    m_yg = yg;
    m_zg = zg;
}

void Particle::SetLife(double life)
{
    m_life = life;
}

void Particle::SetFade(double fade)
{
    m_fade = fade;
}

void Particle::SetActive(bool active)
{
    m_active = active;
}

double Particle::GetPosX()
{
    return m_x;
}

double Particle::GetPosY()
{
    return m_y;
}

double Particle::GetPosZ()
{
    return m_z;
}

bool Particle::GetActive()
{
    return m_active;
}

double Particle::GetLife()
{
    return m_life;
}

double Particle::GetFade()
{
    return m_fade;
}

double Particle::GetColorR()
{
    return m_r;
}

double Particle::GetColorG()
{
    return m_g;
}

double Particle::GetColorB()
{
    return m_b;
}

double Particle::GetMoveX()
{
    return m_xi;
}

double Particle::GetMoveY()
{
    return m_yi;
}

double Particle::GetMoveZ()
{
    return m_zi;
}

double Particle::GetGravityX()
{
    return m_xg;
}

double Particle::GetGravityY()
{
    return m_yg;
}

double Particle::GetGravityZ()
{
    return m_zg;
}

double Particle::GetSize()
{
    return m_size;
}

int initParticles(std::vector<Particle>& particle)
{
    for(int i=0; i<particle.size(); i++)   // Boucle sur toutes les particules
    {
        particle[i].SetActive(true);       // On rend la particule active
        particle[i].SetLife(2);   // Maximum de vie
        particle[i].SetFade(myRand(0.01,0.05));   // Vitesse de disparition aléatoire

        particle[i].SetColor(myRand(0,1), myRand(0,1), myRand(0,1));

        particle[i].SetMove(myRand(-10,10), myRand(-10.0,1), myRand(10,20));

        particle[i].SetGravity(0, 0, -500);
    }
    return 0;    // Initialisation OK
}

int dessinerParticules(std::vector<Particle>& particle, bool regenerate, float r, float g, float b)
{
    for(int i=0; i<particle.size(); i++) // Pour chaque particule
    {
        if(particle[i].GetActive())         // Si elle est active
        {
            float x = particle[i].GetPosX();   // On récupère sa position
            float y = particle[i].GetPosY();
            float z = particle[i].GetPosZ();

            /* Couleur de la particule; transparence = vie */
            glColor4d(particle[i].GetColorR(), particle[i].GetColorG(), particle[i].GetColorB(),
                      particle[i].GetLife());

            /* Dessin de carrés à partir de deux triangles (plus rapide pour la carte video */
            glBegin(GL_TRIANGLE_STRIP);
              glVertex3d(x+particle[i].GetSize() / 10,y,z+particle[i].GetSize() / 10); // Nord-Ouest
              glVertex3d(x-particle[i].GetSize() / 10,y,z+particle[i].GetSize() / 10); // Nord-Est
              glVertex3d(x+particle[i].GetSize() / 10,y,z-particle[i].GetSize() / 10); // Sud-Ouest
              glVertex3d(x-particle[i].GetSize() / 10,y,z-particle[i].GetSize() / 10); // Sud-Est
            glEnd();

            /* Déplacement */
            particle[i].SetPosition(particle[i].GetPosX() + particle[i].GetMoveX() / 1000,
                                    particle[i].GetPosY() + particle[i].GetMoveY() / 1000,
                                    particle[i].GetPosZ() + particle[i].GetMoveZ() / 1000);

            /* Gravité */
            particle[i].SetMove(particle[i].GetMoveX() + particle[i].GetGravityX() / 1000,
                                particle[i].GetMoveY() + particle[i].GetGravityY() / 1000,
                                particle[i].GetMoveZ() + particle[i].GetGravityZ() / 1000);

            /* "Vie" */
            particle[i].SetLife(particle[i].GetLife() - particle[i].GetFade());

            /* Si la particule est "morte" on la régénère */
            if (particle[i].GetLife() < 0 && regenerate)
            {
                particle[i].SetLife(2);   // Maximum de vie
                particle[i].SetFade(myRand(0.01,0.05));   // Vitesse de disparition aléatoire

                particle[i].SetPosition(0,
                                        0,
                                        0);

                particle[i].SetColor(r, g, b);

                particle[i].SetMove(myRand(-10,10), myRand(-10,10), myRand(10,20));
            }
        }
    }
    return 0; // Dessin OK
}

Et enfin voici l'erreur que j'obtient à la compilation (je vire tous les "undeclared" qui prennent une grosse partie de l'erreur ) :

C:\Program Files\CodeBlocks\OpenGL\Particle.cpp:1: error: stray '\239' in program
C:\Program Files\CodeBlocks\OpenGL\Particle.cpp:1: error: stray '\187' in program
C:\Program Files\CodeBlocks\OpenGL\Particle.cpp:1: error: stray '\191' in program
C:\Program Files\CodeBlocks\OpenGL\Particle.cpp:1: error: invalid token

Même quand je supprime la ligne où se trouve l'erreur, j'obtiens la même erreur . D'où cela peut bien venir ?

Merci d'avance pour vos réponses .

Un code minimal serait appréciable. Avec les bonnes lignes... <code debut="15">15e ligne</code>

A lire : http://www.siteduzero.com/tuto-3-198-1 [...] le-zcode.html

J'ai obtenu ce genre d'erreur en faisant un copié/collé depuis un message envoyé par le protocole jabber dans mon code
Je pense que c'est une différence d'encodage des caractères qui est derrière le problème

Si tu a fait un copié/collé : Réécrit tout ton fichier ou se trouve le code a la maib, normalement, l'erreur disparaîtra

Voilà j'ai fait comme tu m'as dit Yunlaaw, j'ai supprimé le fichier, j'ai tout recopié à la main et ça marche très bien maintenant. Encore merci .