SOURCES += \
QSFMLcanvas.cpp
HEADERS += \
QSFMLcanvas.hpp
INCLUDEPATH += D:\Programmes\CodeBlocks\SFML-2.0\include
LIBS += -lsfml-system -lsfml-window -lsfml-graphics -lsfml-audio
QT me dit que create et display n'existent pas dans sfLe message d'erreur exact s'il te plaît ;)
D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\Chip8_simulateur\QSFMLcanvas.cpp:92: erreur : reference to 'create' is ambiguous
D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\..\..\..\Programmes\CodeBlocks\SFML-2.0\include\SFML\Window\Window.hpp:141: erreur : candidates are: void sf::Window::create(HWND__*, const sf::ContextSettings&)
D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\..\..\..\Programmes\CodeBlocks\SFML-2.0\include\SFML\Window\Window.hpp:128: erreur : candidates are: void sf::Window::create(sf::VideoMode, const std::string&, sf::Uint32, const sf::ContextSettings&)
D:\Mes fichiers\Programmation\Projets\Chip8_simulateur-build-desktop-Qt_4_8_0_for_Desktop_-_MinGW__Qt_SDK__Debug\..\..\..\..\Programmes\QtSDK\Desktop\Qt\4.8.0\mingw\include\Qt\qwidget.h:721: error: void QWidget::create(HWND__*, bool, bool)
-L<installation-de-sfml>/lib
#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
#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;
}
#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
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&)'
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.
#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
#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;
}
}
#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
#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;
}
#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
#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
////////////////////////////////////////////////////////////
// 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();
}
#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
#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();
}
defines += SFML_STATIC