Mise en fonction de l'objet Fenetre via SDL

* affichageFenetreSDL.cpp est désormais fonctionnel
Note : Vu la possibilité de ne pouvoir afficher qu'une seule fenêtre avec SDL, la POO pour l'objet fenêtre a été supprimée
* Ajout de test_affichageFenetre.cpp pour tester cet ajout
* Suppression de ce qui était relatif à SDL dans main.cpp
* Mise de analyserCommande() dans un autre fichier pour faciliter l'édition

.gitignore

@@ -1,3 +1,3 @@
-compile.*
+compile*
 bin/*
 *.sublime-*

src/affichageFenetreSDL.cpp

@@ -1,7 +1,112 @@
-int creerFenetre(int dimensionX, int dimensionY, string nom) {
+#include <SDL/SDL.h>
-	return 1;
+#include <string>
+
+int fenetreDimensionX; // Stocke les dimensions X de la fenêtre
+int fenetreDimensionY; // Stocke les dimensions Y de la fenêtre
+SDL_Surface* fenetreEcran;
+SDL_Surface* fenetreImage;
+
+
+void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
+{
+    /*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
+    En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
+    de l'image : 8, 16, 24 ou 32 bits.*/
+    int nbOctetsParPixel = surface->format->BytesPerPixel;
+    /*Ici p est l'adresse du pixel que l'on veut modifier*/
+    /*surface->pixels contient l'adresse du premier pixel de l'image*/
+    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
+
+    /*Gestion différente suivant le nombre d'octets par pixel de l'image*/
+    switch(nbOctetsParPixel)
+    {
+        case 1:
+            *p = pixel;
+            break;
+
+        case 2:
+            *(Uint16 *)p = pixel;
+            break;
+
+        case 3:
+            /*Suivant l'architecture de la machine*/
+            if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
+            {
+                p[0] = (pixel >> 16) & 0xff;
+                p[1] = (pixel >> 8) & 0xff;
+                p[2] = pixel & 0xff;
+            }
+            else
+            {
+                p[0] = pixel & 0xff;
+                p[1] = (pixel >> 8) & 0xff;
+                p[2] = (pixel >> 16) & 0xff;
+            }
+            break;
+
+        case 4:
+            *(Uint32 *)p = pixel;
+            break;
+    }
 }
 
-int point(int x, int y) {
+int ouvrirFenetre(int dimensionX, int dimensionY, std::string nom) {  // Crée une fenêtre
-	return 1;
+	SDL_Init(SDL_INIT_VIDEO);
+	fenetreDimensionX = dimensionX;
+	fenetreDimensionY = dimensionY;
+	fenetreEcran = SDL_SetVideoMode(fenetreDimensionX, fenetreDimensionY, 32, SDL_HWSURFACE);
+	fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX, fenetreDimensionX, 32, 0, 0, 0, 0);
+	SDL_FillRect(fenetreImage, NULL, SDL_MapRGB(fenetreEcran->format, 0, 0, 0));
+	setNomFenetre(nom);
+	return 0;
+}
+
+int setNomFenetre(std::string nom) { // Change le nom de la fenêtre
+	SDL_WM_SetCaption(nom.c_str(), NULL);
+	return 0;
+}
+
+int pointFenetre(int x, int y, int r, int v, int b) {
+	// TODO (erreur) Vérifications des dimensions
+
+	// std::cout << "(" << x << ";" << y << ") = (" << r << ";" << v << ";" << b << ")" << std::endl; // DEBUG
+
+	Uint32 pixel;
+
+	Uint8 u_r, u_v, u_b, u_a;
+	u_r = (Uint8) (r > 255 ? 255 : r); // TODO (performance, facultatif, erreur) Si > 255, on renvoit 0xff sinon on convertit
+	u_v = (Uint8) (v > 255 ? 255 : v);
+	u_b = (Uint8) (b > 255 ? 255 : b);
+	u_a = (Uint8) 255;
+
+	pixel = SDL_MapRGBA(fenetreImage->format, u_r, u_v, u_b, u_a);
+
+	SDL_LockSurface(fenetreImage);
+	definirPixel(fenetreImage, x, y, pixel);
+	SDL_UnlockSurface(fenetreImage);
+
+	return 0;
+}
+
+int afficherFenetre() {
+	// TODO (performance, facultatif) fenetreImage pourrait être crée pendant afficherFenetre(), et pointFenetre() ne modifierait qu'un tableau
+	SDL_Rect position;
+	position.x = 0; position.y = 0;
+	SDL_BlitSurface(fenetreImage, NULL, fenetreEcran, &position);
+	SDL_Flip(fenetreEcran);
+	return 0;
+}
+
+int attendreFenetre() {
+	SDL_Event evenement;
+
+    while (evenement.type != SDL_QUIT) {
+    	SDL_WaitEvent(&evenement);
+    }
+}
+
+int fermerFenetre() {
+	SDL_FreeSurface(fenetreImage);
+	SDL_Quit();
+	return 0;
 }

src/affichageFenetreSDL.h

@@ -1,12 +0,0 @@
-class Fenetre {
-
-public: 
-	int Fenetre(int dimensionX, int dimensionY, string nom); // Crée une fenêtre
-	int setNom(string nom); // Change le nom de la fenêtre
-	int point(int x, int y);
-private:
-	int dimensionX; // Stocke les dimensions X de la fenêtre
-	int dimensionY; // Stocke les dimensions Y de la fenêtre
-	string m_nom; // Stocke le nom de la fenêtre
-	vector< vector< int[3] > > tab; // Tableau qui stocke les pixels
-};

src/analyserCommande.cpp

@@ -0,0 +1,3 @@
+function analyserCommande(string nom) {
+
+}

src/image.h

@@ -6,6 +6,9 @@ public:
 	int getB(); // Récupère la composante Bleu
 	int getG(); // Récupère la composante Gris
 	bool getN(); // Récupère la composante Noir
+	int getTypeComposantes(); // Récupère le type de composante
+	int getMaxComposantes(); // Récupère le maximum de composante
+
 	int setR(int R); // Change la composante Rouge
 	int setV(int V); // Change la composante Vert
 	int setB(int B); // Change la composante Bleu
@@ -24,6 +27,12 @@ private:
 
 class Image {
 public:
-	int Image(int dimensionX, int dimensionY, int maxComposante); // Crée l'objet Image
+	int Image(int dimensionX, int dimensionY, int maxComposante, int typeComposantes); // Crée l'objet Image
 	int point(int x, int y, Pixel pixel); // Définit une couleur au point
+	Pixel getPoint(int x, int y);
+
+private:
+	int m_typeComposantes; // 0 : N&B, 1 : Niveaux de gris, 2 : RVB
+	int m_maxComposante; // Maximum de composante (inutilisé pour binaire)
+	vector< vector< Pixel > > m_tab;
 };

src/main.cpp

@@ -1,9 +1,15 @@
 #include <iostream>
 #include <string>
-#include "SDL/SDL.h"
+
+#include "affichageFenetreSDL.cpp" // Devrait charger le .h mais le programme est relativement simple (sans Makefile) donc on assemble tout en même temps
+
 
 using namespace std;
 
+// Insertion des ensembles de fonctions massives séparés pour plus de clarté
+#include "analyserCommande.cpp"
+#include "traitementImage.cpp"
+
 int main(int argc, char* args[]) {
 
 #if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
@@ -11,13 +17,7 @@ int main(int argc, char* args[]) {
 	freopen("CON", "w", stderr);
 #endif
 
-    SDL_Init(SDL_INIT_EVERYTHING);
+	cout << "PILG" << endl; // Message d'entrée et de test
-
-    SDL_Quit();
 
     return 0;
 }
-
-int analyserCommande(string commande) {
-
-}

src/test_affichageFenetre.cpp

@@ -0,0 +1,36 @@
+#include <iostream>
+#include <string>
+
+#include "affichageFenetreSDL.cpp" // Devrait charger le .h mais le programme est relativement simple (sans Makefile) donc on assemble tout en même temps
+
+using namespace std;
+
+
+int main(int argc, char* args[]) {
+
+#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
+	freopen("CON", "w", stdout);
+	freopen("CON", "w", stderr);
+#endif
+
+	cout << "TEST AFFICHAGE FENETRE" << endl; // Message d'entrée et de test
+
+	int dimX = 640, dimY = 480;
+	ouvrirFenetre(dimX, dimY, "Test affichage fenêtre");
+
+	for (int c = 0; c <= 255; c++) { // À peu près 58 FPS
+		for (int x = 0; x <= dimX; x++) {
+			for (int y = 0; y <= dimY; y++) {
+				pointFenetre(x, y, c, 255-c, 0);
+			}
+		}
+		afficherFenetre();
+	}
+
+	cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
+	attendreFenetre();
+	fermerFenetre();
+
+
+    return 0;
+}