Import xayon40-12 utilities

Components that can be reused in other programs.

utilityInput/Input.cpp

@@ -0,0 +1,93 @@
+#include "Input.h"
+
+Input::Input(): m_x(0), m_y(0), m_xRel(0), m_yRel(0), m_continuer(true)
+{
+    for(int i = 0;i<512;i++)
+        m_touches[i] = R_RELACHER;
+
+    for(int i = 0;i<8;i++)
+        m_boutonsSouris[i] = R_RELACHER;
+}
+Input::~Input()
+{
+
+}
+
+void Input::updateEvenement()
+{
+    m_xRel = 0;
+    m_yRel = 0;
+
+    while(SDL_PollEvent(&m_evenement))
+    {
+        switch(m_evenement.type)
+        {
+        case SDL_QUIT:
+            m_continuer = false;
+            break;
+
+        case SDL_KEYDOWN:
+            m_touches[m_evenement.key.keysym.sym] = (m_touches[m_evenement.key.keysym.scancode] & R_RELACHER)?APPUYER:R_APPUYER;
+            break;
+
+        case SDL_KEYUP:
+            m_touches[m_evenement.key.keysym.sym] = (m_touches[m_evenement.key.keysym.scancode] & R_APPUYER)?RELACHER:R_RELACHER;
+            break;
+
+        case SDL_MOUSEBUTTONDOWN:
+            m_boutonsSouris[m_evenement.button.button] = (m_boutonsSouris[m_evenement.button.button] & R_RELACHER)?APPUYER:R_APPUYER;
+            break;
+
+        case SDL_MOUSEBUTTONUP:
+            m_boutonsSouris[m_evenement.button.button] = (m_boutonsSouris[m_evenement.button.button] & R_APPUYER)?RELACHER:R_RELACHER;
+            break;
+
+        case SDL_MOUSEMOTION:
+            m_x = m_evenement.motion.x;
+            m_y = m_evenement.motion.y;
+
+            m_xRel = m_evenement.motion.xrel;
+            m_yRel = m_evenement.motion.yrel;
+            break;
+
+        default:
+            break;
+        }
+    }
+}
+bool Input::continuer() const
+{
+    return m_continuer;
+}
+int Input::getTouches(const SDLKey touche) const
+{
+    return m_touches[touche];
+}
+int Input::getBoutonSouris(const Uint8 bouton) const
+{
+    return m_boutonsSouris[bouton];
+}
+bool Input::mouvementSouris() const
+{
+    if(m_xRel == 0 && m_yRel == 0)
+        return false;
+
+    else
+        return true;
+}
+int Input::getX() const
+{
+    return m_x;
+}
+int Input::getY() const
+{
+    return m_y;
+}
+int Input::getXRel() const
+{
+    return m_xRel;
+}
+int Input::getYRel() const
+{
+   return m_yRel;
+}

utilityInput/Input.h

@@ -0,0 +1,40 @@
+#ifndef INPUT_H_INCLUDED
+#define INPUT_H_INCLUDED
+
+#include <SDL/SDL.h>
+#undef main
+
+enum etat {APPUYER = 0b0001, R_APPUYER = 0b0011, RELACHER = 0b0100, R_RELACHER = 0b1100};
+/*le R veut dire que l'on reste
+ex: appuyer -> vrai juste au moment de l'appui
+    Rappuyer -> vrai tout pendant que la touche reste enfoncé
+*/
+
+class Input
+{
+public:
+    Input();
+    ~Input();
+
+    void updateEvenement();
+    bool continuer() const;
+    int getTouches(const SDLKey touche) const;
+    int getBoutonSouris(const Uint8 bouton) const;
+    bool mouvementSouris() const;
+    int getX() const;
+    int getY() const;
+    int getXRel() const;
+    int getYRel() const;
+
+private:
+    SDL_Event m_evenement;
+    int m_touches[512];
+    int m_boutonsSouris[8];
+
+    int m_x, m_y;
+    int m_xRel, m_yRel;
+
+    bool m_continuer;
+};
+
+#endif // INPUT_H_INCLUDED

utilityNetwork/Client.cpp

@@ -0,0 +1,68 @@
+#include "Client.h"
+
+Client::Client(std::string IP, int port): m_IP(IP), m_port(port)
+{
+    m_csock.recsize = sizeof(m_csock.sin);
+    std::cout << "-°*,-Programme Client-,*°-" << std::endl;
+    std::cout << "Initialisation..." << std::endl;
+    #ifdef WIN32
+        m_erreur = WSAStartup(MAKEWORD(2,2), &m_WSAData);
+    #else
+        m_erreur = 0;
+    #endif // WIN32
+}
+
+Client::~Client()
+{
+    std::cout << "Fermeture de la socket client" << std::endl;
+    closesocket(m_csock.sock);
+    std::cout << "Fermeture du client termine" << std::endl;
+    #ifdef WIN32
+        WSACleanup();
+    #endif // WIN32
+}
+
+
+
+bool Client::rendreUtilisable()
+{
+    if(!m_erreur)
+    {
+        m_csock.sock = socket(AF_INET,SOCK_STREAM, 0);
+        if(m_csock.sock != INVALID_SOCKET)
+        {
+            std::cout << "La socket " << m_csock.sock << " est maintenant ouverte en mode TCP/IP" << std::endl;
+            m_csock.sin.sin_addr.s_addr = inet_addr(m_IP.c_str());
+            m_csock.sin.sin_family = AF_INET;
+            m_csock.sin.sin_port = htons(m_port);
+
+            if(connect(m_csock.sock, (SOCKADDR*)&m_csock.sin, m_csock.recsize) != SOCKET_ERROR)
+            {
+                std::cout << "Connection a " << inet_ntoa(m_csock.sin.sin_addr) << " sur le port " << htons(m_csock.sin.sin_port) << " reussie" << std::endl;
+            }
+            else
+                return false;
+        }
+        else
+            return false;
+    }
+    else
+        return false;
+    return true;
+}
+
+void Client::envoyer(int *donnee, int tailleByte)
+{
+    if(tailleByte != 0)
+        send(m_csock.sock, (char*)donnee, tailleByte, 0);
+    else
+        send(m_csock.sock, (char*)donnee, sizeof(*donnee), 0);
+}
+
+void Client::recevoir(int *donnee, int tailleByte)
+{
+    if(tailleByte != 0)
+        recv(m_csock.sock, (char*)donnee, tailleByte, 0);
+    else
+        recv(m_csock.sock, (char*)donnee, sizeof(*donnee), 0);
+}

utilityNetwork/Client.h

@@ -0,0 +1,55 @@
+#ifndef CLIENT_H_INCLUDED
+#define CLIENT_H_INCLUDED
+
+#ifdef WIN32
+    #include <winsock2.h>
+    typedef int socklen_t;
+#elif defined (linux)
+    #include <sys/types.h>
+    #include <sys/socket.h>
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+    #include <unistd.h>
+
+    #define INVALID_SOCKET -1
+    #define SOCKET_ERROR -1
+    #define closesocket(s) close (s)
+
+    typedef int SOCKET;
+    typedef struct sockaddr_in SOCKADDR_IN;
+    typedef struct sockaddr SOCKADDR;
+
+#endif // WIN32
+#include <iostream>
+#include <pthread.h>
+
+struct Sock
+{
+    SOCKADDR_IN sin;
+    SOCKET sock;
+    socklen_t recsize;
+};
+
+class Client
+{
+public:
+    Client(std::string IP, int port);
+    ~Client();
+
+    bool rendreUtilisable();
+    void envoyer(int *donnee, int tailleByte = 0);
+    void recevoir(int *donnee, int tailleByte = 0);
+
+private:
+    #ifdef WIN32
+    WSADATA m_WSAData;
+    #endif
+
+    Sock m_csock;
+
+    std::string m_IP;
+    int m_port;
+    int m_erreur;
+};
+
+#endif // CLIENT_H_INCLUDED

utilityNetwork/Serveur.cpp

@@ -0,0 +1,86 @@
+#include "Serveur.h"
+
+Serveur::Serveur(int port): m_port(port)
+{
+    #ifdef WIN32
+        m_erreur = WSAStartup(MAKEWORD(2,2), &m_WSAData);
+    #else
+        m_erreur = 0;
+    #endif // WIN32
+    m_sock.recsize = sizeof(m_sock.sin);
+    for(int i = 0;i<NBR_CLIENT;i++)
+        m_csock[i].recsize = sizeof(m_csock[i].sin);
+
+}
+
+Serveur::~Serveur()
+{
+    #ifdef WIN32
+        WSACleanup();
+    #endif // WIN32
+    std::cout << "Fermeture des sockets clientes" << std::endl;
+    for(int i = 0;i<NBR_CLIENT;i++)
+        closesocket(m_csock[i].sock);
+    std::cout << "Fermeture de la socket serveur" << std::endl;
+    closesocket(m_sock.sock);
+    std::cout << "Fermeture du serveur termine" << std::endl;
+}
+
+
+bool Serveur::rendreUtilisable()
+{
+    if(!m_erreur)
+    {
+        m_sock.sock = socket(AF_INET, SOCK_STREAM, 0);// SOCK_STREAM pour TCP/IP, SOCK_DGRAM pour UDP/IP
+        if(m_sock.sock != INVALID_SOCKET)
+        {
+            std::cout << "La socket " << m_sock.sock << " est maintenant ouverte en mode TCP/IP" << std::endl;
+            m_sock.sin.sin_addr.s_addr = htonl(INADDR_ANY);
+            m_sock.sin.sin_family = AF_INET;
+            m_sock.sin.sin_port = htons(m_port);
+            if(bind(m_sock.sock, (SOCKADDR*)&m_sock.sin, m_sock.recsize) != SOCKET_ERROR)
+            {
+                std::cout << "Listage du port " << m_port << "..." << std::endl;
+                if(listen(m_sock.sock, 5) != SOCKET_ERROR)
+                {
+                    std::cout << "Patientez pendant que les " << NBR_CLIENT << " clients se connectent sur le port " << m_port << "..." << std::endl;
+                    for(int i = 0;i<NBR_CLIENT;i++)
+                    {
+                        m_csock[i].sock = accept(m_sock.sock, (SOCKADDR*)&m_csock[i].sin, &m_csock[0].recsize);// renvoi INVALID_SOCKET si il y a un probleme
+                        if(m_csock[i].sock != INVALID_SOCKET)
+                        {
+                            std::cout << "Un clien se connect avec la socket " << m_csock[i].sock << " de " << inet_ntoa(m_csock[i].sin.sin_addr) << " : " << htons(m_csock[i].sin.sin_port) << std::endl;
+                        }
+                        else
+                            return false;
+                    }
+                }
+                else
+                    return false;
+            }
+            else
+                return false;
+        }
+        else
+            return false;
+    }
+    else
+        return false;
+    return true;
+}
+
+void Serveur::envoyer(int *donnee, int indice, int tailleByte)
+{
+    if(tailleByte != 0)
+        send(m_csock[indice].sock, (char*)donnee, tailleByte, 0);
+    else
+        send(m_csock[indice].sock, (char*)donnee, sizeof(*donnee), 0);
+}
+
+void Serveur::recevoir(int *donnee, int indice, int tailleByte)
+{
+    if(tailleByte != 0)
+        send(m_csock[indice].sock, (char*)donnee, tailleByte, 0);
+    else
+        send(m_csock[indice].sock, (char*)donnee, sizeof(*donnee), 0);
+}

utilityNetwork/Serveur.h

@@ -0,0 +1,55 @@
+#ifndef SERVEUR_H_INCLUDED
+#define SERVEUR_H_INCLUDED
+#ifdef WIN32
+    #include <winsock2.h>
+    typedef int socklen_t;
+#elif defined (linux)
+    #include <sys/types.h>
+    #include <sys/socket.h>
+    #include <netinet/in.h>
+    #include <arpa/inet.h>
+    #include <unistd.h>
+
+    #define INVALID_SOCKET -1
+    #define SOCKET_ERROR -1
+    #define closesocket(s) close (s)
+
+    typedef int SOCKET;
+    typedef struct sockaddr_in SOCKADDR_IN;
+    typedef struct sockaddr SOCKADDR;
+
+#endif // WIN32
+#include <iostream>
+
+#define NBR_CLIENT 2
+struct Sock
+{
+    SOCKADDR_IN sin;
+    SOCKET sock;
+    socklen_t recsize;
+};
+
+class Serveur
+{
+public:
+    Serveur(int port);
+    ~Serveur();
+
+    bool rendreUtilisable();
+    void envoyer(int *donnee, int indice, int tailleByte = 0);
+    void recevoir(int *donnee, int indice, int tailleByte = 0);
+
+
+private:
+    #ifdef WIN32
+    WSADATA m_WSAData;
+    #endif
+
+    Sock m_sock;
+    Sock m_csock[NBR_CLIENT];
+
+    int m_port;
+    int m_erreur;
+};
+
+#endif // SERVEUR_H_INCLUDED

utilityVector/Vecteur.cpp

@@ -0,0 +1,235 @@
+#include "Vecteur.h"
+#include <cmath>
+
+Vecteur::Vecteur() : m_x(0.0), m_y(0.0), m_z(0.0)
+{
+
+}
+Vecteur::Vecteur(float x, float y, float z) : m_x(x), m_y(y), m_z(z)
+{
+
+}
+Vecteur::Vecteur(const Vecteur &vecteur) : m_x(vecteur.getX()), m_y(vecteur.getY()), m_z(vecteur.getZ())
+{
+
+}
+Vecteur::~Vecteur()
+{
+
+}
+float Vecteur::getX() const
+{
+    return m_x;
+}
+
+float Vecteur::getY() const
+{
+    return m_y;
+}
+
+float Vecteur::getZ() const
+{
+    return m_z;
+}
+
+
+// Setters
+
+void Vecteur::setVecteur(float x, float y, float z)
+{
+    m_x = x;
+    m_y = y;
+    m_z = z;
+}
+
+void Vecteur::setX(float x)
+{
+    m_x = x;
+}
+
+void Vecteur::setY(float y)
+{
+    m_y = y;
+}
+
+void Vecteur::setZ(float z)
+{
+    m_z = z;
+}
+void Vecteur::normaliser()
+{
+    // La fonction sqrt() permet de trouver la racine carré d'un nombre
+
+    float longueur (sqrt(m_x * m_x + m_y * m_y + m_z * m_z));
+
+
+    // Normalisation du vecteur
+
+    if(longueur != 0.0)
+    {
+        m_x /= longueur;
+        m_y /= longueur;
+        m_z /= longueur;
+    }
+}
+Vecteur& Vecteur::operator=(const Vecteur &vecteur)
+{
+    // Copie des valeurs
+
+    m_x = vecteur.m_x;
+    m_y = vecteur.m_y;
+    m_z = vecteur.m_z;
+
+
+    // Retour de l'objet
+
+    return *this;
+}
+Vecteur Vecteur::operator+(const Vecteur &vecteur)
+{
+    // Création d'un objet résultat
+
+    Vecteur resultat;
+
+
+    // Addition des coordonnées
+
+    resultat.m_x = m_x + vecteur.m_x;
+    resultat.m_y = m_y + vecteur.m_y;
+    resultat.m_z = m_z + vecteur.m_z;
+
+
+    // Retour de résultat
+
+    return resultat;
+}
+Vecteur Vecteur::operator-(const Vecteur &vecteur)
+{
+    // Création d'un objet résultat
+
+    Vecteur resultat;
+
+
+    // Soustraction des coordonnées
+
+    resultat.m_x = m_x - vecteur.m_x;
+    resultat.m_y = m_y - vecteur.m_y;
+    resultat.m_z = m_z - vecteur.m_z;
+
+
+    // Retour de résultat
+
+    return resultat;
+}
+Vecteur Vecteur::operator*(float multiplicateur)
+{
+    // Création d'un objet résultat
+
+    Vecteur resultat;
+
+
+    // Multiplication des coordonnées
+
+    resultat.m_x = m_x * multiplicateur;
+    resultat.m_y = m_y * multiplicateur;
+    resultat.m_z = m_z * multiplicateur;
+
+
+    // Retour du résultat
+
+    return resultat;
+}
+Vecteur Vecteur::operator/(float diviseur)
+{
+    // Création d'un objet résultat
+
+    Vecteur resultat;
+
+
+    // Multiplication des coordonnées
+
+    resultat.m_x = m_x / diviseur;
+    resultat.m_y = m_y / diviseur;
+    resultat.m_z = m_z / diviseur;
+
+
+    // Retour du résultat
+
+    return resultat;
+}
+Vecteur Vecteur::operator*(const Vecteur &vecteur)
+{
+    // Création d'un objet résultat
+
+    Vecteur resultat;
+
+
+    // Produit Vectoriel
+
+    resultat.m_x = (m_y * vecteur.m_z) - (m_z * vecteur.m_y);
+    resultat.m_y = (m_z * vecteur.m_x) - (m_x * vecteur.m_z);
+    resultat.m_z = (m_x * vecteur.m_y) - (m_y * vecteur.m_x);
+
+
+    // Retour de l'objet
+
+    return resultat;
+}
+void Vecteur::operator*=(const Vecteur &vecteur)
+{
+    *this = *this * vecteur;
+}
+void Vecteur::operator-=(const Vecteur &vecteur)
+{
+    *this = *this - vecteur;
+}
+void Vecteur::operator+=(const Vecteur &vecteur)
+{
+    *this = *this + vecteur;
+}
+void Vecteur::operator*=(float multiplicateur)
+{
+    *this = *this * multiplicateur;
+}
+void Vecteur::operator/=(float multiplicateur)
+{
+    *this = *this * multiplicateur;
+}
+float Vecteur::scalair(const Vecteur &vecteur)
+{
+    Vecteur v1(*this), v2(vecteur);
+    v1.normaliser();
+    v2.normaliser();
+    return v1.getX() * v2.getX() + v1.getY() * v2.getY() + v1.getZ() * v2.getZ();
+}
+bool Vecteur::operator==(const Vecteur &vecteur)
+{
+    if(m_x == vecteur.getX() && m_y == vecteur.getY() && m_z == vecteur.getZ())
+        return true;
+    else
+        return false;
+}
+bool Vecteur::operator!=(const Vecteur &vecteur)
+{
+    if(*this == vecteur)
+        return false;
+    else
+        return true;
+}
+double Vecteur::norme()
+{
+    return sqrt(m_x*m_x+m_y*m_y+m_z*m_z);
+}
+void Vecteur::rotateR(float angle)
+{
+    float tmp = m_x;
+    m_x = cos(angle)*m_x-sin(angle)*m_y;
+    m_y = sin(angle)*tmp+cos(angle)*m_y;
+}
+void Vecteur::rotateD(float angle)
+{
+    float _angle = angle*M_PI/180;
+    float tmp = m_x;
+    m_x = cos(_angle)*m_x-sin(_angle)*m_y;
+    m_y = sin(_angle)*tmp+cos(_angle)*m_y;
+}

utilityVector/Vecteur.h

@@ -0,0 +1,46 @@
+#ifndef VECTEUR_H_INCLUDED
+#define VECTEUR_H_INCLUDED
+
+#include <cmath>
+
+class Vecteur
+{
+    public:
+
+    Vecteur();
+    Vecteur(float x, float y, float z = 0);
+    Vecteur(const Vecteur &vecteur);
+    ~Vecteur();
+    float getX() const;
+    float getY() const;
+    float getZ() const;
+    void setVecteur(float x, float y, float z);
+    void setX(float x);
+    void setY(float y);
+    void setZ(float z);
+    void normaliser();
+    Vecteur& operator=(const Vecteur &vecteur);
+    Vecteur operator+(const Vecteur &vecteur);
+    Vecteur operator-(const Vecteur &vecteur);
+    Vecteur operator*(float multiplicateur);
+    Vecteur operator/(float diviseur);
+    Vecteur operator*(const Vecteur &vecteur);
+    void operator*=(const Vecteur &vecteur);
+    void operator-=(const Vecteur &vecteur);
+    void operator+=(const Vecteur &vecteur);
+    void operator*=(float multiplicateur);
+    void operator/=(float multiplicateur);
+    float scalair(const Vecteur &vecteur);
+    bool operator==(const Vecteur &vecteur);
+    bool operator!=(const Vecteur &vecteur);
+    double norme();
+    void rotateR(float angle); // angle en radians
+    void rotateD(float angle); // angle en degrées
+
+private:
+    float m_x;
+    float m_y;
+    float m_z;
+};
+
+#endif // VECTEUR_H_INCLUDED