Le programme ne répond plus

[Laurent]

Ah ben nous y voilà, tu aurais dû parler de ce problème et de ta modif dès le début.

Ce n'est pas par sf:: qu'il faut préfixer dans ce cas, mais par la classe : sf::RenderWindow::.

[Aaltar]

Ah merci !
Dernière chose, maintenant il me dit:
:-1: erreur : cannot find -lsfml-system

et ce pour les autres (graphics...etc), qu'ai je oublié dans mon .pro ?
Merci

[Laurent]

Ca :

Code: [Sélectionner]

-L<installation-de-sfml>/lib

[Aaltar]

Merci, ça marche inpec.

Par contre, une de mes classes, la classe écran qui dessine dans la fenêtre, dont le constructeur attend un pointeur sur un RenderWindows à l'origine.
Je modifie ma classe pour qu'il accepte un Mycanvas (car il dit quemon MyCanvas n'est pas RenderWindows, normalement vue qu'il en hérite, il en est un nom ? )à la place. Mais j'ai des erreurs que je ne comprends pas, si tu peux m'aider encore s'il te plait.

Mon code:

Code: [Sélectionner]

#ifndef ECRAN_HPP_INCLUDED
#define ECRAN_HPP_INCLUDED

#include "pixel.hpp"
#include "MyCanvas.hpp"



#define l 64      //nombre de pixels suivant la longueur
#define L 32       //nombre de pixels suivant la largueur
#define DIMPIXEL 8


class Ecran
{
    public:
    Ecran(MyCanvas* app);

    void dessiner(Pixel* pixel);
    void update();
    void clear();

    Pixel* getPixel(int x, int y);



    private:
    Pixel m_pixel[l][L];
    MyCanvas* m_app;




};


#endif // ECRAN_HPP_INCLUDED


Code: [Sélectionner]

#include "ecran.hpp"

Ecran::Ecran(MyCanvas* app)
{
    for(int x(0);x<l;x++)
    {
        for(int y(0);y<L;y++)
        {
            m_pixel[x][y] = Pixel(x,y);
        }
    }


    m_app = app;
}




void Ecran::dessiner(Pixel* pixel)
{
    sf::RectangleShape m_rect(sf::Vector2f(DIMPIXEL,DIMPIXEL));
    m_rect.setFillColor(pixel->couleur);
    m_rect.setPosition(pixel->position.x*8, pixel->position.y*8);
    m_app->draw(m_rect);

}

void Ecran::update()
{
    sf::Uint8 x=0,y=0;

    for(x=0;x<l;x++)
    {
        for(y=0;y<L;y++)
        {
             dessiner(getPixel(x, y));
        }
    }

    m_app->display();


}

void Ecran::clear()
{
    sf::Uint8 x=0,y=0;

    for(x=0;x<l;x++)
    {
        for(y=0;y<L;y++)
        {
            m_pixel[x][y].couleur = sf::Color::Black;
        }
    }

    m_app->clear();
}

Pixel* Ecran::getPixel(int x, int y)
{
    Pixel* pointeur;
    pointeur = &m_pixel[x][y];
    return pointeur;
}




Code: [Sélectionner]

#ifndef MYCANVAS_HPP
#define MYCANVAS_HPP

#include "QSFMLcanvas.hpp"
#include "cpu.hpp"
#include "ecran.hpp"

#include "QSFMLcanvas.hpp"

class MyCanvas : public QSFMLCanvas
{
public :

    MyCanvas(QWidget* Parent, const QPoint& Position, const QSize& Size) :
    QSFMLCanvas(Parent, Position, Size), m_ecran(*this), m_cpu(&m_ecran)
    {

    }

private :

    void OnInit()
    {
        m_cpu.chargerJeu("Maze.ch8");
    }
    void OnUpdate()
    {
        sf::Event event;
        while(pollEvent(event))
                {

                    m_cpu.getEvent(event);
                    m_cpu.lireEvent();
                    switch(event.type)
                    {
                        case sf::Event::Closed:
                            sf::RenderWindow::close();
                            break;

                        default:
                            break;
                    }
                }
                for(int i(0);i<4;i++)
                {
                    m_cpu.interpreter(m_cpu.getOpcode());
                }

                m_cpu.jouerSon();

                m_ecran.update();
                m_cpu.decompter();
    }


    sf::Texture  m_texture;
    sf::Sprite mySprite;
    Ecran m_ecran;
    CPU m_cpu;

};


#endif // MYCANVAS_HPP



Les erreurs:

Code: [Sélectionner]

D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\Chip8_simulateur\ecran.hpp:17: erreur : expected ')' before '*' token

D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\Chip8_simulateur\ecran.hpp:29: erreur : ISO C++ forbids declaration of 'MyCanvas' with no type

D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\Chip8_simulateur\ecran.hpp:29: erreur : expected ';' before '*' token

D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\Chip8_simulateur\MyCanvas.hpp:15: erreur : no matching function for call to 'Ecran::Ecran(MyCanvas&)'

[Laurent]

Tu as une boucle infinie d'inclusions : ecran.hpp inclue mycanvas.hpp et vice-versa.

[Aaltar]

Ah oui, mais comment l'éviter, ils ont besoin l'un de l'autre...

[Laurent]

Quand tu ne fais que déclarer des pointeurs, tu peux t'en tirer avec une simple déclaration anticipée de la classe.

class MyCanvas;

Bien sûr il faut tout de même inclure l'en-tête ensuite dans le fichier .cpp, là où tu utilises la classe.

Et comme ton problème n'avait rien à voir, utilise à nouveau sf::RenderWindow, ce sera beaucoup plus propre

[Aaltar]

 J'ai un problème, je ne peux pas envoyer &this au constructeur de mon ecran...
Car j'ai D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\Chip8_simulateur\MyCanvas.hpp:15: erreur : lvalue required as unary '&' operand .

[Laurent]

Sur quelle ligne de code ? Et pourquoi &this (MyCanvas**) ??

[Aaltar]

 MyCanvas(QWidget* Parent, const QPoint& Position, const QSize& Size) :
    QSFMLCanvas(Parent, Position, Size), m_ecran(&this), m_cpu(&m_ecran)
    {

    }

Car le constructeur de écran à besoin d'un pointeur sur un renderwindows.

[Laurent]

Et bien dans ce cas juste "this", c'est déjà un pointeur.

[Aaltar]

Ah ok, merci.
C'est bon, cela compile par contre, ça clignote... J'ai très souvent un ecran noir, l'image apparaissant très rarement durant une fraction de seconde. Et tout va super vite... Alors qu'en console cela marchait très bien.

Ah et quand j'ai voulu linker la sfml de manière statique, j'ai eu 750 erreurs étrange, avec des entrées inconnues...etc

[Laurent]

C'est bon, cela compile par contre, ça clignote... J'ai très souvent un ecran noir, l'image apparaissant très rarement durant une fraction de seconde.

Ca dépend comment tu gères l'affichage, faudrait voir ton code.

Ah et quand j'ai voulu linker la sfml de manière statique, j'ai eu 750 erreurs étrange, avec des entrées inconnues...

Lorsque tu utilises les bibliothèques statiques de SFML, il faut définir la macro SFML_STATIC dans ton projet.

[Aaltar]

Ah ok et où je définie ce macro dans mon .pro ?

Voila mon code totale:

Code: [Sélectionner]

#ifndef CPU_HPP_INCLUDED
#define CPU_HPP_INCLUDED

#include <SFML/System.hpp>
#include <SFML/Audio.hpp>

#include <iostream>
#include <fstream>
#include <string>

#include "ecran.hpp"

#define TAILLEMEMOIRE 4096
#define ADRESSEDEBUT 512
#define NBROPCODE 35


class CPU
{
    public:
    CPU(Ecran* ecran);
    ~CPU();
    void decompter();

    sf::Uint8 getAction(sf::Uint16 opcode);
    sf::Uint16 getOpcode();

    void interpreter(sf::Uint16 opcode);
    void dessiner(sf::Uint8 b1,sf::Uint8 b2, sf::Uint8 b3);
    void chargerFont();
    void chargerMasque();

    void attendAppui(sf::Uint8 b3);
    void getEvent(sf::Event event);
    void lireEvent();

    void jouerSon();

    bool chargerJeu(std::string nomJeu);


    private:
    sf::Uint8 memoire[TAILLEMEMOIRE];
    sf::Uint8 V[16]; //le registre
    sf::Uint16 I; //stocke une adresse mémoire ou dessinateur
    sf::Uint16 saut[16]; //pour gérer les sauts dans « mémoire », 16 au maximum
    sf::Uint8 nbrsaut; //stocke le nombre de sauts effectués pour ne pas dépasser 16
    sf::Uint8 compteurJeu; //compteur pour la synchronisation
    sf::Uint8 compteurSon; //compteur pour le son
    sf::Uint16 pc; //pour parcourir le tableau « mémoire »
    sf::Uint16 masque [NBROPCODE]; // tableau des masques
    sf::Uint16 id[NBROPCODE]; // tableau id
    sf::Uint8 touche[16]; //pour stocker l'état des touches

    Ecran* m_ecran;

    sf::Event m_event;

    sf::SoundBuffer m_SBuffer;
    sf::Sound m_sound;

};



#endif // CPU_HPP_INCLUDED


Code: [Sélectionner]

#include "cpu.hpp"

CPU::CPU(Ecran* ecran)
{
    for(int i(0);i<TAILLEMEMOIRE;i++)
    {
        memoire[i]=0;
    }

    for(int i(0);i<16;i++)
    {
        V[i]=0;
        saut[i]=0;
        touche[i]=0;
    }

    pc=ADRESSEDEBUT;
    nbrsaut=0;
    compteurJeu=0;
    compteurSon=0;
    I=0;


    m_ecran = ecran;

    chargerFont();
    chargerMasque();

    char beep[] = {
        #include "beep.aiff.hpp"
        };
    m_SBuffer.loadFromMemory(beep, sizeof(beep));
    m_sound.setBuffer(m_SBuffer);
}


CPU::~CPU()
{


}

void CPU::decompter()
{
    if(compteurJeu>0)
    compteurJeu--;

    if(compteurSon>0)
    compteurSon--;
}


sf::Uint16 CPU::getOpcode()
{
    return (memoire[pc]<<8)+memoire[pc+1];
}

sf::Uint8 CPU::getAction(sf::Uint16 opcode)
{
    sf::Uint8 action;
    sf::Uint16 resultat;

    for(action=0;action<NBROPCODE;action++)
    {
        resultat= (masque[action]&opcode);

        if(resultat == id[action])
           break;
    }

    return action;
}

void CPU::dessiner(sf::Uint8 b1,sf::Uint8 b2, sf::Uint8 b3)
{
    sf::Uint8 x=0,y=0,k=0,codage=0,j=0,decalage=0;
    V[0xF]=0;

     for(k=0;k<b1;k++)
    {
        codage=memoire[I+k];

        y=(V[b2]+k)%L;

        for(j=0,decalage=7;j<8;j++,decalage--)
        {

            x=(V[b3]+j)%l;

            if(((codage)&(0x1<<decalage))!=0)
            {
                if( m_ecran->getPixel(x,y)->couleur==sf::Color::White)
                {
                    m_ecran->getPixel(x,y)->couleur=sf::Color::Black;
                    V[0xF]=1;


                }
                else
                {
                    m_ecran->getPixel(x,y)->couleur=sf::Color::White;
                }


            }

        }
    }

}



void CPU::interpreter(sf::Uint16 opcode)
{
    sf::Uint8 b4,b3,b2,b1;

    b3=(opcode&(0x0F00))>>8;
    b2=(opcode&(0x00F0))>>4;
    b1=(opcode&(0x000F));

    b4 = getAction(opcode);

    switch(b4)
    {
     case 0:{
               //Cet opcode n'est pas implémenté.
                break;
              }
     case 1:{
            //00E0 efface l'écran.
                m_ecran->clear();
                break;
               }

     case 2:{
            //00EE revient du saut.

                if(nbrsaut>0)
                {
                    nbrsaut--;
                    pc=saut[nbrsaut];
                }
                break;
            }
    case 3:{
            //1NNN effectue un saut à l'adresse 1NNN.

                pc=(b3<<8)+(b2<<4)+b1;
                pc-=2;

                break;
            }
    case 4:{
            //2NNN appelle le sous-programme en NNN, mais on revient ensuite.

                saut[nbrsaut]=pc;
                if(nbrsaut<15)
                {
                    nbrsaut++;
                }

                pc=(b3<<8)+(b2<<4)+b1;
                pc-=2;

                break;
            }
    case 5:{
            //3XNN saute l'instruction suivante si VX est égal à NN.

                if(V[b3]==((b2<<4)+b1))
                {
                    pc+=2;
                }

                break;
            }
    case 6:{
            //4XNN saute l'instruction suivante si VX et NN ne sont pas égaux.
                if(V[b3]!=((b2<<4)+b1))
                {
                    pc+=2;
                }

                break;
            }
    case 7:{
           //5XY0 saute l'instruction suivante si VX et VY sont égaux.
                if(V[b3]==V[b2])
                {
                    pc+=2;
                }

                break;
            }

    case 8:{
            //6XNN définit VX à NN.
                V[b3]=(b2<<4)+b1;
                break;
            }
    case 9:{
                //7XNN ajoute NN à VX.
                V[b3]+=(b2<<4)+b1;

                break;
            }
    case 10:{
                //8XY0 définit VX à la valeur de VY.
                V[b3]=V[b2];

                break;
            }
    case 11:{
                //8XY1 définit VX à VX OR VY.
                V[b3]=V[b3]|V[b2];

                break;
            }
    case 12:{
                //8XY2 définit VX à VX AND VY.
                V[b3]=V[b3]&V[b2];

                break;
            }
    case 13:{
                //8XY3 définit VX à VX XOR VY.
                V[b3]=V[b3]^V[b2];

                break;
            }
    case 14:{
                //8XY4 ajoute VY à VX. VF est mis à 1 quand il y a un dépassement de mémoire (carry), et à 0 quand il n'y en pas.
                if((V[b3]+V[b2])>255)
                {
                    V[0xF]=1;
                }
                else
                {
                    V[0xF]=0;
                }
                V[b3]+=V[b2];

                break;
            }
    case 15:{
                //8XY5 VY est soustraite de VX. VF est mis à 0 quand il y a un emprunt, et à 1 quand il n'y a en pas.

                if((V[b3]<V[b2]))
                {
                    V[0xF]=0;
                }
                else
                {
                    V[0xF]=1;
                }
                V[b3]-=V[b2];

                break;
            }
    case 16:{
                //8XY6 décale (shift) VX à droite de 1 bit. VF est fixé à la valeur du bit de poids faible de VX avant le décalage.
                V[0xF]=(V[b3]&(0x01));
                V[b3]=(V[b3]>>1);

                break;
            }
    case 17:{
                //8XY7 VX = VY - VX. VF est mis à 0 quand il y a un emprunt et à 1 quand il n'y en a pas.
                if((V[b2]<V[b3]))
                {
                    V[0xF]=0;
                }
                else
                {
                    V[0xF]=1;
                }
                V[b3]=V[b2]-V[b3];

                break;
            }
    case 18:{
                //8XYE décale (shift) VX à gauche de 1 bit. VF est fixé à la valeur du bit de poids fort de VX avant le décalage.
                V[0xF]=(V[b3]>>7);
                V[b3]=(V[b3]<<1);

                break;
             }

    case 19:{
                //9XY0 saute l'instruction suivante si VX et VY ne sont pas égaux.
                if(V[b3]!=V[b2])
                    {
                        pc+=2;
                    }

                break;
            }
    case 20:{
            //ANNN affecte NNN à I.

                I=(b3<<8)+(b2<<4)+b1;

                break;
            }
    case 21:{
           //BNNN passe à l'adresse NNN + V0.

            pc=(b3<<8)+(b2<<4)+b1+V[0];
            pc-=2;

            break;

            }
    case 22:{
            //CXNN définit VX à un nombre aléatoire inférieur à NN.
            V[b3]=(rand())%((b2<<4)+b1+1);

            break;

            }

    case 23:{
           //DXYN dessine un sprite aux coordonnées (VX, VY).


            dessiner(b1,b2,b3) ;

            break;

            }
    case 24:{
                 //EX9E saute l'instruction suivante si la clé stockée dans VX est pressée.
                if(touche[V[b3]]==1)
                {
                    pc+=2;
                }

                break;
            }
    case 25:{
                //EXA1 saute l'instruction suivante si la clé stockée dans VX n'est pas pressée.
                if(touche[V[b3]]==0)
                {
                    pc+=2;
                }

                break;
            }

    case 26:{
                 //FX07 définit VX à la valeur de la temporisation.
                V[b3]=compteurJeu;

                break;
            }
    case 27:{
                //FX0A attend l'appui sur une touche et stocke ensuite la donnée dans VX.
                attendAppui(b3);

                break;
            }


    case 28:{
               //FX15 définit la temporisation à VX.
                compteurJeu=V[b3];

                break;
            }
    case 29:{
                //FX18 définit la minuterie sonore à VX.
                compteurSon=V[b3];

                break;
            }
    case 30:{
             //FX1E ajoute VX à I. VF est mis à 1 quand il y a overflow (I+VX>0xFFF), et à 0 si tel n'est pas le cas.

                if((I+V[b3])>0xFFF)
                {
                    V[0xF]=1;
                }
                else
                {
                    V[0xF]=0;
                }
                I+=V[b3];


                break;
            }

    case 31:{
                 //FX29 définit I à l'emplacement du caractère stocké dans VX. Les caractères 0-F (en hexadécimal) sont représentés par une police 4x5.
                I=V[b3]*5;

                break;
            }

    case 32:{
                //FX33 stocke dans la mémoire le code décimal représentant VX (dans I, I+1, I+2).

                memoire[I]=(V[b3]-V[b3]%100)/100;
                memoire[I+1]=(((V[b3]-V[b3]%10)/10)%10);
                memoire[I+2]=V[b3]-memoire[I]*100-10*memoire[I+1];

                break;
            }
    case 33:{
                //FX55 stocke V0 à VX en mémoire à partir de l'adresse I.
                sf::Uint8 i=0;
                for(i=0;i<=b3;i++)
                {
                    memoire[I+i]=V[i];
                }

                break;
            }
    case 34:{
                 //FX65 remplit V0 à VX avec les valeurs de la mémoire à partir de l'adresse I.

                sf::Uint8 i=0;

                for(i=0;i<=b3;i++)
                {
                  V[i]=memoire[I+i];
                }

                break;
            }

    default: { //erreur

                    break;
             }

   }
    pc+=2; //on passe au prochain opcode

}


bool CPU::chargerJeu(std::string nomJeu)
{
    std::ifstream f(nomJeu.c_str(), std::ios::in|std::ios::binary);

    if(f.is_open())
    {
        f.read((char *)&memoire[ADRESSEDEBUT],sizeof(sf::Uint8)*(TAILLEMEMOIRE-ADRESSEDEBUT));
        f.close();
        return true;
    }
    else
    {
        std::cout << "Erreur au chargement du jeu";
        f.close();
        return false;
    }

}


void CPU::chargerFont()
{
    memoire[0]=0xF0;memoire[1]=0x90;memoire[2]=0x90;memoire[3]=0x90; memoire[4]=0xF0; // O
    memoire[5]=0x20;memoire[6]=0x60;memoire[7]=0x20;memoire[8]=0x20;memoire[9]=0x70; // 1
    memoire[10]=0xF0;memoire[11]=0x10;memoire[12]=0xF0;memoire[13]=0x80; memoire[14]=0xF0; // 2
    memoire[15]=0xF0;memoire[16]=0x10;memoire[17]=0xF0;memoire[18]=0x10;memoire[19]=0xF0; // 3
    memoire[20]=0x90;memoire[21]=0x90;memoire[22]=0xF0;memoire[23]=0x10;memoire[24]=0x10; // 4
    memoire[25]=0xF0;memoire[26]=0x80;memoire[27]=0xF0;memoire[28]=0x10;memoire[29]=0xF0; // 5
    memoire[30]=0xF0;memoire[31]=0x80;memoire[32]=0xF0;memoire[33]=0x90;memoire[34]=0xF0; // 6
    memoire[35]=0xF0;memoire[36]=0x10;memoire[37]=0x20;memoire[38]=0x40;memoire[39]=0x40; // 7
    memoire[40]=0xF0;memoire[41]=0x90;memoire[42]=0xF0;memoire[43]=0x90;memoire[44]=0xF0; // 8
    memoire[45]=0xF0;memoire[46]=0x90;memoire[47]=0xF0;memoire[48]=0x10;memoire[49]=0xF0; // 9
    memoire[50]=0xF0;memoire[51]=0x90;memoire[52]=0xF0;memoire[53]=0x90;memoire[54]=0x90; // A
    memoire[55]=0xE0;memoire[56]=0x90;memoire[57]=0xE0;memoire[58]=0x90;memoire[59]=0xE0; // B
    memoire[60]=0xF0;memoire[61]=0x80;memoire[62]=0x80;memoire[63]=0x80;memoire[64]=0xF0; // C
    memoire[65]=0xE0;memoire[66]=0x90;memoire[67]=0x90;memoire[68]=0x90;memoire[69]=0xE0; // D
    memoire[70]=0xF0;memoire[71]=0x80;memoire[72]=0xF0;memoire[73]=0x80;memoire[74]=0xF0; // E
    memoire[75]=0xF0;memoire[76]=0x80;memoire[77]=0xF0;memoire[78]=0x80;memoire[79]=0x80; // F
}

void CPU::chargerMasque()
{
    masque[0]= 0x0000; id[0]=0x0FFF;          /* 0NNN */
    masque[1]= 0xFFFF; id[1]=0x00E0;          /* 00E0 */
    masque[2]= 0xFFFF; id[2]=0x00EE;          /* 00EE */
    masque[3]= 0xF000; id[3]=0x1000;          /* 1NNN */
    masque[4]= 0xF000; id[4]=0x2000;          /* 2NNN */
    masque[5]= 0xF000; id[5]=0x3000;          /* 3XNN */
    masque[6]= 0xF000; id[6]=0x4000;          /* 4XNN */
    masque[7]= 0xF00F; id[7]=0x5000;          /* 5XY0 */
    masque[8]= 0xF000; id[8]=0x6000;          /* 6XNN */
    masque[9]= 0xF000; id[9]=0x7000;          /* 7XNN */
    masque[10]= 0xF00F; id[10]=0x8000;        /* 8XY0 */
    masque[11]= 0xF00F; id[11]=0x8001;        /* 8XY1 */
    masque[12]= 0xF00F; id[12]=0x8002;        /* 8XY2 */
    masque[13]= 0xF00F; id[13]=0x8003;        /* BXY3 */
    masque[14]= 0xF00F; id[14]=0x8004;        /* 8XY4 */
    masque[15]= 0xF00F; id[15]=0x8005;        /* 8XY5 */
    masque[16]= 0xF00F; id[16]=0x8006;        /* 8XY6 */
    masque[17]= 0xF00F; id[17]=0x8007;        /* 8XY7 */
    masque[18]= 0xF00F; id[18]=0x800E;        /* 8XYE */
    masque[19]= 0xF00F; id[19]=0x9000;        /* 9XY0 */
    masque[20]= 0xF000; id[20]=0xA000;        /* ANNN */
    masque[21]= 0xF000; id[21]=0xB000;        /* BNNN */
    masque[22]= 0xF000; id[22]=0xC000;        /* CXNN */
    masque[23]= 0xF000; id[23]=0xD000;        /* DXYN */
    masque[24]= 0xF0FF; id[24]=0xE09E;        /* EX9E */
    masque[25]= 0xF0FF; id[25]=0xE0A1;        /* EXA1 */
    masque[26]= 0xF0FF; id[26]=0xF007;        /* FX07 */
    masque[27]= 0xF0FF; id[27]=0xF00A;        /* FX0A */
    masque[28]= 0xF0FF; id[28]=0xF015;        /* FX15 */
    masque[29]= 0xF0FF; id[29]=0xF018;        /* FX18 */
    masque[30]= 0xF0FF; id[30]=0xF01E;        /* FX1E */
    masque[31]= 0xF0FF; id[31]=0xF029;        /* FX29 */
    masque[32]= 0xF0FF; id[32]=0xF033;        /* FX33 */
    masque[33]= 0xF0FF; id[33]=0xF055;        /* FX55 */
    masque[34]= 0xF0FF; id[34]=0xF065;        /* FX65 */
}


void CPU::getEvent(sf::Event event)
{
    m_event = event;
}

void CPU::attendAppui(sf::Uint8 b3)
{
    sf::Uint8 attend=1;

    while(attend)
    {
        if(m_event.type == sf::Event::KeyPressed)
        {
            switch (m_event.key.code)
            {
                case sf::Keyboard::Numpad0:{V[b3]=0x0; touche[0x0]=1; attend=0;break;}
                case sf::Keyboard::Numpad7:{ V[b3]=0x1; touche[0x1]=1; attend=0;break;}
                case sf::Keyboard::Numpad8:{ V[b3]=0x2; touche[0x2]=1; attend=0;break;}
                case sf::Keyboard::Numpad9:{ V[b3]=0x3; touche[0x3]=1; attend=0;break;}
                case sf::Keyboard::Numpad4:{ V[b3]=0x4; touche[0x4]=1; attend=0;break;}
                case sf::Keyboard::Numpad5:{ V[b3]=0x5; touche[0x5]=1; attend=0;break;}
                case sf::Keyboard::Numpad6:{ V[b3]=0x6; touche[0x6]=1; attend=0;break;}
                case sf::Keyboard::Numpad3:{ V[b3]=0x7; touche[0x7]=1; attend=0;break;}
                case sf::Keyboard::Numpad2:{ V[b3]=0x8; touche[0x8]=1; attend=0;break;}
                case sf::Keyboard::Numpad1:{ V[b3]=0x9; touche[0x9]=1; attend=0;break;}
                case sf::Keyboard::Right:{ V[b3]=0xA; touche[0xA]=1;  attend=0;break;}
                case sf::Keyboard::Period:{ V[b3]=0xB; touche[0xB]=1;  attend=0;break;}
                case sf::Keyboard::Multiply:{ V[b3]=0xC; touche[0xC]=1;  attend=0;break;}
                case sf::Keyboard::Subtract:{ V[b3]=0xD; touche[0xD]=1;  attend=0;break;}
                case sf::Keyboard::Add:{ V[b3]=0xE; touche[0xE]=1;  attend=0;break;}
                case sf::Keyboard::Return:{ V[b3]=0xF; touche[0xF]=1;  attend=0;break;}
                default:{ break;}

            }

        }
    }
}

void CPU::lireEvent()
{
    if(m_event.type == sf::Event::KeyPressed)
    {
        switch (m_event.key.code)
        {
            case sf::Keyboard::Numpad0:{ touche[0x0]=1;break;}
            case sf::Keyboard::Numpad7:{ touche[0x1]=1;break;}
            case sf::Keyboard::Numpad8:{ touche[0x2]=1;break;}
            case sf::Keyboard::Numpad9:{ touche[0x3]=1;break;}
            case sf::Keyboard::Numpad4:{ touche[0x4]=1;break;}
            case sf::Keyboard::Numpad5:{ touche[0x5]=1;break;}
            case sf::Keyboard::Numpad6:{ touche[0x6]=1;break;}
            case sf::Keyboard::Numpad3:{ touche[0x7]=1;break;}
            case sf::Keyboard::Numpad2:{ touche[0x8]=1;break;}
            case sf::Keyboard::Numpad1:{ touche[0x9]=1;break;}
            case sf::Keyboard::Right:{ touche[0xA]=1;break;}
            case sf::Keyboard::Period:{touche[0xB]=1;break;}
            case sf::Keyboard::Multiply:{touche[0xC]=1;break;}
            case sf::Keyboard::Subtract:{touche[0xD]=1;break;}
            case sf::Keyboard::Add:{touche[0xE]=1;break;}
            case sf::Keyboard::Return:{touche[0xF]=1;break;}
            default:{ break;}
        }

    }
    else if(m_event.type == sf::Event::KeyReleased)
    {
        switch (m_event.key.code)
        {
            case sf::Keyboard::Numpad0:{ touche[0x0]=0;break;}
            case sf::Keyboard::Numpad7:{ touche[0x1]=0;break;}
            case sf::Keyboard::Numpad8:{ touche[0x2]=0;break;}
            case sf::Keyboard::Numpad9:{ touche[0x3]=0;break;}
            case sf::Keyboard::Numpad4:{ touche[0x4]=0;break;}
            case sf::Keyboard::Numpad5:{ touche[0x5]=0;break;}
            case sf::Keyboard::Numpad6:{ touche[0x6]=0;break;}
            case sf::Keyboard::Numpad3:{ touche[0x7]=0;break;}
            case sf::Keyboard::Numpad2:{ touche[0x8]=0;break;}
            case sf::Keyboard::Numpad1:{ touche[0x9]=0;break;}
            case sf::Keyboard::Right:{ touche[0xA]=0;break;}
            case sf::Keyboard::Period:{touche[0xB]=0;break;}
            case sf::Keyboard::Multiply:{touche[0xC]=0;break;}
            case sf::Keyboard::Subtract:{touche[0xD]=0;break;}
            case sf::Keyboard::Add:{touche[0xE]=0;break;}
            case sf::Keyboard::Return:{touche[0xF]=0;break;}
            default:{ break;}

        }

    }
    else{}
}

void CPU::jouerSon()
{
    if(compteurSon!=0)
 {
    m_sound.play();
    compteurSon=0;

 }
}



Code: [Sélectionner]

#ifndef ECRAN_HPP_INCLUDED
#define ECRAN_HPP_INCLUDED

#include "pixel.hpp"





#define l 64      //nombre de pixels suivant la longueur
#define L 32       //nombre de pixels suivant la largueur
#define DIMPIXEL 8


class Ecran
{
    public:
    Ecran(sf::RenderWindow* app);

    void dessiner(Pixel* pixel);
    void update();
    void clear();

    Pixel* getPixel(int x, int y);



    private:
    Pixel m_pixel[l][L];
    sf::RenderWindow* m_app;


};


#endif // ECRAN_HPP_INCLUDED


Code: [Sélectionner]

#include "ecran.hpp"

Ecran::Ecran(sf::RenderWindow* app)
{
    for(int x(0);x<l;x++)
    {
        for(int y(0);y<L;y++)
        {
            m_pixel[x][y] = Pixel(x,y);
        }
    }


    m_app = app;
}




void Ecran::dessiner(Pixel* pixel)
{
    sf::RectangleShape m_rect(sf::Vector2f(DIMPIXEL,DIMPIXEL));
    m_rect.setFillColor(pixel->couleur);
    m_rect.setPosition(pixel->position.x*8, pixel->position.y*8);
    m_app->draw(m_rect);

}

void Ecran::update()
{
    sf::Uint8 x=0,y=0;

    for(x=0;x<l;x++)
    {
        for(y=0;y<L;y++)
        {
             dessiner(getPixel(x, y));
        }
    }

    m_app->display();


}

void Ecran::clear()
{
    sf::Uint8 x=0,y=0;

    for(x=0;x<l;x++)
    {
        for(y=0;y<L;y++)
        {
            m_pixel[x][y].couleur = sf::Color::Black;
        }
    }

    m_app->clear();
}

Pixel* Ecran::getPixel(int x, int y)
{
    Pixel* pointeur;
    pointeur = &m_pixel[x][y];
    return pointeur;
}




Code: [Sélectionner]

#ifndef PIXEL_HPP_INCLUDED
#define PIXEL_HPP_INCLUDED

#include <SFML/Graphics.hpp>

class Pixel
{
    public:
    Pixel(int x, int y);
    Pixel();

    sf::Color couleur;
    sf::Vector2f position;

};


#endif // PIXEL_HPP_INCLUDED


Code: [Sélectionner]

#ifndef QSFMLCANVAS_HPP
#define QSFMLCANVAS_HPP

////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include <SFML/Graphics.hpp>
#include <Qt/qwidget.h>
#include <Qt/qtimer.h>


////////////////////////////////////////////////////////////
/// QSFMLCanvas allows to run SFML in a Qt control
////////////////////////////////////////////////////////////
class QSFMLCanvas : public QWidget, public sf::RenderWindow
{
public :

    ////////////////////////////////////////////////////////////
    /// Construct the QSFMLCanvas
    ///
    /// \param Parent :    Parent of the widget
    /// \param Position :  Position of the widget
    /// \param Size :      Size of the widget
    /// \param FrameTime : Frame duration, in milliseconds (0 by default)
    ///
    ////////////////////////////////////////////////////////////
    QSFMLCanvas(QWidget* Parent, const QPoint& Position, const QSize& Size, unsigned int FrameTime = 0);

    ////////////////////////////////////////////////////////////
    /// Destructor
    ///
    ////////////////////////////////////////////////////////////
    virtual ~QSFMLCanvas();

private :

    ////////////////////////////////////////////////////////////
    /// Notification for the derived class that moment is good
    /// for doing initializations
    ///
    ////////////////////////////////////////////////////////////
    virtual void OnInit();

    ////////////////////////////////////////////////////////////
    /// Notification for the derived class that moment is good
    /// for doing its update and drawing stuff
    ///
    ////////////////////////////////////////////////////////////
    virtual void OnUpdate();

    ////////////////////////////////////////////////////////////
    /// Return the paint engine used by the widget to draw itself
    ///
    ////////////////////////////////////////////////////////////
    virtual QPaintEngine* paintEngine() const;

    ////////////////////////////////////////////////////////////
    /// Called when the widget is shown ;
    /// we use it to initialize our SFML window
    ///
    ////////////////////////////////////////////////////////////
    virtual void showEvent(QShowEvent*);

    ////////////////////////////////////////////////////////////
    /// Called when the widget needs to be painted ;
    /// we use it to display a new frame
    ///
    ////////////////////////////////////////////////////////////
    virtual void paintEvent(QPaintEvent*);

    ////////////////////////////////////////////////////////////
    // Member data
    ////////////////////////////////////////////////////////////
    QTimer myTimer;       ///< Timer used to update the view
    bool   myInitialized; ///< Tell whether the SFML window has been initialized or not
};


#endif // QSFMLCANVAS_HPP


Code: [Sélectionner]

////////////////////////////////////////////////////////////
// Headers
////////////////////////////////////////////////////////////
#include "QSFMLCanvas.hpp"

// Platform-specific headers
#ifdef Q_WS_X11
    #include <Qt/qx11info_x11.h>
    #include <X11/Xlib.h>
#endif


////////////////////////////////////////////////////////////
/// Construct the QSFMLCanvas
////////////////////////////////////////////////////////////
QSFMLCanvas::QSFMLCanvas(QWidget* Parent, const QPoint& Position, const QSize& Size, unsigned int FrameTime) :
QWidget       (Parent),
myInitialized (false)
{
    // Setup some states to allow direct rendering into the widget
    setAttribute(Qt::WA_PaintOnScreen);
    setAttribute(Qt::WA_OpaquePaintEvent);
    setAttribute(Qt::WA_NoSystemBackground);

    // Set strong focus to enable keyboard events to be received
    setFocusPolicy(Qt::StrongFocus);

    // Setup the widget geometry
    move(Position);
    resize(Size);

    // Setup the timer
    myTimer.setInterval(FrameTime);
}


////////////////////////////////////////////////////////////
/// Destructor
////////////////////////////////////////////////////////////
QSFMLCanvas::~QSFMLCanvas()
{
    // Nothing to do...
}


////////////////////////////////////////////////////////////
/// Notification for the derived class that moment is good
/// for doing initializations
////////////////////////////////////////////////////////////
void QSFMLCanvas::OnInit()
{
    // Nothing to do by default...
}


////////////////////////////////////////////////////////////
/// Notification for the derived class that moment is good
/// for doing its update and drawing stuff
////////////////////////////////////////////////////////////
void QSFMLCanvas::OnUpdate()
{
    // Nothing to do by default...
}


////////////////////////////////////////////////////////////
/// Return the paint engine used by the widget to draw itself
////////////////////////////////////////////////////////////
QPaintEngine* QSFMLCanvas::paintEngine() const
{
    return 0;
}


////////////////////////////////////////////////////////////
/// Called when the widget is shown ;
/// we use it to initialize our SFML window
////////////////////////////////////////////////////////////
void QSFMLCanvas::showEvent(QShowEvent*)
{
    if (!myInitialized)
    {
        // Under X11, we need to flush the commands sent to the server to ensure that
        // SFML will get an updated view of the windows
        #ifdef Q_WS_X11
            XFlush(QX11Info::display());
        #endif

        // Create the SFML window with the widget handle
        sf::RenderWindow::create(winId());

        // Let the derived class do its specific stuff
        OnInit();

        // Setup the timer to trigger a refresh at specified framerate
        connect(&myTimer, SIGNAL(timeout()), this, SLOT(repaint()));
        myTimer.start();

        myInitialized = true;
    }
}


////////////////////////////////////////////////////////////
/// Called when the widget needs to be painted ;
/// we use it to display a new frame
////////////////////////////////////////////////////////////
void QSFMLCanvas::paintEvent(QPaintEvent*)
{
    // Let the derived class do its specific stuff
    OnUpdate();

    // Display on screen
    display();
}


Code: [Sélectionner]

#ifndef MYCANVAS_HPP
#define MYCANVAS_HPP

#include "QSFMLcanvas.hpp"
#include "cpu.hpp"


#include "QSFMLcanvas.hpp"

class MyCanvas : public QSFMLCanvas
{
public :

    MyCanvas(QWidget* Parent, const QPoint& Position, const QSize& Size) :
    QSFMLCanvas(Parent, Position, Size), m_ecran(this), m_cpu(&m_ecran)
    {

    }

private :

    void OnInit()
    {
        m_cpu.chargerJeu("Pong.ch8");

    }
    void OnUpdate()
    {
        sf::Event event;
        while(pollEvent(event))
        {

                m_cpu.getEvent(event);
                m_cpu.lireEvent();
        }
                for(int i(0);i<4;i++)
                {
                    m_cpu.interpreter(m_cpu.getOpcode());
                }

                m_cpu.jouerSon();

                m_ecran.update();
                m_cpu.decompter();
    }


    sf::Texture  m_texture;
    sf::Sprite mySprite;
    Ecran m_ecran;
    CPU m_cpu;

};


#endif // MYCANVAS_HPP


Code: [Sélectionner]

#include <QtGui>
#include "MyCanvas.hpp"

int main(int argc, char **argv)
{
    QApplication App(argc, argv);

    // On crée la fenêtre principale
    QFrame* MainFrame = new QFrame;
    MainFrame->setWindowTitle("Qt SFML");
    MainFrame->resize(512, 256);
    MainFrame->show();

    //On crée une vue SFML dans la fenêtre principale
    MyCanvas* SFMLView = new MyCanvas(MainFrame, QPoint(0, 0), QSize(512, 256));
    SFMLView->show();

    return App.exec();
}



Mon code marchait très bien en console.
Et sinon comment changer la "taille des pixels", avec une fenetre sfml quand on l'agrandit les pixels "grossissent", mais on ne change pas leur nombre, si je puis dire comme ça. Comment faire ce ci avec la fenetre QT, car si j'utilise setsize je vais changer la résolution.

[Laurent]

Dans le .pro :

Code: [Sélectionner]

defines += SFML_STATIC
Pour le reste, désolé là j'ai plus le temps, on verra plus tard