Import color generator

sdl1/colorGenerator/Input.cpp

@@ -0,0 +1,176 @@
+#include "Input.h"
+
+
+// Constructeur et Destructeur
+Input::Input()
+: m_x(0), m_y(0), m_xRel(0), m_yRel(0),
+m_terminer(false), m_relativeMouse(false), m_windowHalfHeight(0), m_windowHalfWidth(0)
+{
+    // Initialisation du tableau m_touches[]
+    for(int i(0); i < SDLK_LAST; i++)
+        m_touches[i] = false;
+    std::cout << "Il y a "<<SDLK_LAST<<" touches sur le clavier."<<std::endl;
+
+    // Initialisation du tableau m_boutonsSouris[]
+    for(int i(0); i < 8; i++)
+        m_boutonsSouris[i] = false;
+}
+
+
+Input::~Input()
+{}
+
+
+// Méthodes
+void Input::updateEvenements()
+{
+    // Pour éviter des mouvements fictifs de la souris, on réinitialise les coordonnées relatives
+    m_xRel = 0;
+    m_yRel = 0;
+
+    // Boucle d'évènements
+    while(SDL_PollEvent(&m_evenements))
+    {
+        // Switch sur le type d'évènement
+        switch(m_evenements.type)
+        {
+            // Cas d'une touche enfoncée
+            case SDL_KEYDOWN:
+                m_touches[m_evenements.key.keysym.sym] = true;
+            break;
+
+            // Cas d'une touche relâchée
+            case SDL_KEYUP:
+                m_touches[m_evenements.key.keysym.sym] = false;
+            break;
+
+            // Cas de pression sur un bouton de la souris
+            case SDL_MOUSEBUTTONDOWN:
+                m_boutonsSouris[m_evenements.button.button] = true;
+            break;
+
+            // Cas du relâchement d'un bouton de la souris
+            case SDL_MOUSEBUTTONUP:
+                m_boutonsSouris[m_evenements.button.button] = false;
+            break;
+
+            // Cas d'un mouvement de souris
+            case SDL_MOUSEMOTION:
+                if (m_relativeMouse)
+                {
+                    m_xRel = m_evenements.motion.x-m_windowHalfWidth;
+                    m_yRel = m_evenements.motion.y-m_windowHalfHeight;
+                }
+                else
+                {
+                    m_x = m_evenements.motion.x;
+                    m_y = m_evenements.motion.y;
+                    m_xRel = m_evenements.motion.xrel;
+                    m_yRel = m_evenements.motion.yrel;
+                }
+
+            break;
+
+            // Cas de la fermeture de la fenêtre
+            case SDL_QUIT:
+                m_terminer = true;
+            break;
+
+            // Les autres ne nous interessent pas : on évite de faire râler g++
+            default:
+            break;
+        }
+    }
+
+    // Pour éviter que la souris se barre en mode relative, on la "warp"
+    if (m_relativeMouse)
+         SDL_WarpMouse(m_windowHalfWidth, m_windowHalfHeight);
+}
+
+
+bool Input::terminer() const
+{
+    return m_terminer;
+}
+
+
+void Input::afficherPointeur(bool reponse) const
+{
+    if(reponse)
+        SDL_ShowCursor(SDL_ENABLE);
+
+    else
+        SDL_ShowCursor(SDL_DISABLE);
+}
+
+
+void Input::capturerPointeur(bool reponse)
+{
+    m_relativeMouse = reponse;
+}
+
+
+
+// Getters
+
+bool Input::getTouche(const int touche) const
+{
+    return m_touches[touche];
+}
+
+
+bool 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;
+}
+
+
+// Getters concernant la position du curseur
+
+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;
+}
+
+void Input::placerPtr(SDL_Surface* activWindow)
+{
+    // Détermination de l'endroit de capture du pointeur
+    m_windowHalfWidth = activWindow->w / 2;
+    m_windowHalfHeight = activWindow->h / 2;
+}
+
+int Input::getWinHalfH()
+{
+    return m_windowHalfHeight;
+}
+
+int Input::getWinHalfW()
+{
+    return m_windowHalfWidth;
+}
+

sdl1/colorGenerator/Input.h

@@ -0,0 +1,61 @@
+#ifndef DEF_INPUT
+#define DEF_INPUT
+
+///Jovian
+///Adaptation pour InputAndJoy
+
+// Include
+#include <iostream>
+#include <SDL.h>
+
+
+// Classe
+class Input
+{
+    public:
+
+    Input();
+    virtual ~Input();
+
+    virtual void updateEvenements();
+
+    bool terminer() const;
+    void afficherPointeur(bool reponse) const;
+    void capturerPointeur(bool reponse);
+
+    bool getTouche(const int touche) const;
+    bool getBoutonSouris(const Uint8 bouton) const;
+    bool mouvementSouris() const;
+
+    int getX() const;
+    int getY() const;
+
+    int getXRel() const;
+    int getYRel() const;
+
+    void placerPtr(SDL_Surface* activWindow);
+
+    int getWinHalfH();
+    int getWinHalfW();
+
+
+    protected:
+
+    SDL_Event m_evenements;
+    bool m_touches[SDLK_LAST];
+    bool m_boutonsSouris[8];
+
+    int m_x;
+    int m_y;
+    int m_xRel;
+    int m_yRel;
+
+    bool m_terminer;
+    bool m_relativeMouse;
+
+    int m_windowHalfHeight;
+    int m_windowHalfWidth;
+};
+
+#endif
+

sdl1/colorGenerator/main.cpp

@@ -0,0 +1,171 @@
+#include <cstdlib>
+#include <SDL.h>
+#include "Input.h"
+#include "SDL_gfxPrimitives.h"
+
+int main ( int argc, char** argv )
+{
+    // initialize SDL video
+    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
+    {
+        printf( "Unable to init SDL: %s\n", SDL_GetError() );
+        return 1;
+    }
+
+    // make sure SDL cleans up before exit
+    atexit(SDL_Quit);
+
+    // create a new window
+    Uint16 w(1440), h(900);
+    SDL_Surface* screen = SDL_SetVideoMode(w, h, 32,
+                                           SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_FULLSCREEN);
+    if ( !screen )
+    {
+        printf("Unable to set video: %s\n", SDL_GetError());
+        return 1;
+    }
+
+    // variables
+    SDL_Rect dstrect;
+    const Uint32 delay(18);
+    Uint32 tps( SDL_GetTicks() ), tps_old(0);
+
+    // graph
+    int i(0);
+    int r(128), g(128), b(128);
+    bool ubr(false), ubg(false), ubb(false);
+    bool dbr(false), dbg(false), dbb(false);
+
+    // program main loop
+    bool done = false;
+    while (!done)
+    {
+        // message processing loop
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            // check for messages
+            switch (event.type)
+            {
+                // exit if the window is closed
+            case SDL_QUIT:
+                done = true;
+                break;
+
+                // check for keypresses
+            case SDL_KEYDOWN:
+                // exit if ESCAPE is pressed
+                switch ( event.key.keysym.sym )
+                {
+                case SDLK_ESCAPE:
+                    done = true;
+                    break;
+                case SDLK_KP7:
+                    ubr = true;
+                    dbr = false;
+                    break;
+                case SDLK_KP1:
+                    ubr = false;
+                    dbr = true;
+                    break;
+                case SDLK_KP8:
+                    ubg = true;
+                    dbg = false;
+                    break;
+                case SDLK_KP2:
+                    ubg = false;
+                    dbg = true;
+                    break;
+                case SDLK_KP9:
+                    ubb = true;
+                    dbb = false;
+                    break;
+                case SDLK_KP3:
+                    ubb = false;
+                    dbb = true;
+                    break;
+                default:
+                    break;
+                }
+                break;
+
+            case SDL_KEYUP:
+                switch ( event.key.keysym.sym )
+                {
+                case SDLK_KP7:
+                    ubr = false;
+                    dbr = false;
+                    break;
+                case SDLK_KP1:
+                    ubr = false;
+                    dbr = false;
+                    break;
+                case SDLK_KP8:
+                    ubg = false;
+                    dbg = false;
+                    break;
+                case SDLK_KP2:
+                    ubg = false;
+                    dbg = false;
+                    break;
+                case SDLK_KP9:
+                    ubb = false;
+                    dbb = false;
+                    break;
+                case SDLK_KP3:
+                    ubb = false;
+                    dbb = false;
+                    break;
+                default:
+                    break;
+                }
+                break;
+
+            } // end switch event tye
+        } // end of message processing
+
+        if ( r < 255 && ubr ) r++;
+        if ( r > 0 && dbr ) r--;
+        if ( g < 255 && ubg ) g++;
+        if ( g > 0 && dbg ) g--;
+        if ( b < 255 && ubb ) b++;
+        if ( b > 0 && dbb ) b--;
+
+        // calculs
+        i++;
+        if ( i > w ) i = 0;
+
+        // DRAWING STARTS HERE
+        vlineRGBA(screen, i, 0, h, r/2, g/2, b/2, 255);
+        roundedBoxRGBA(screen, 15, 15, w-15, h-400, 15, r, g, b, 255);
+
+        for ( int j(1); j<=3; j++ )
+        {
+            filledCircleRGBA(screen, j*w/4, h-200, 149, 128, 128, 128, 255);
+        }
+
+        filledPieRGBA(screen, w/4, h-200, 150, 0, r*359/255, 255, 0, 0, 255 );
+        filledPieRGBA(screen, w/2, h-200, 150, 0, g*359/255, 0, 255, 0, 255 );
+        filledPieRGBA(screen, 3*w/4, h-200, 150, 0, b*359/255, 0, 0, 255, 255 );
+
+        stringRGBA(screen, w/4+140, h-130, "Rouge", 255, 0, 0, 255);
+        stringRGBA(screen, w/2+140, h-130, "Vert", 0, 255, 0, 255);
+        stringRGBA(screen, 3*w/4+140, h-130, "Bleu", 0, 0, 255, 255);
+
+        // DRAWING ENDS HERE
+
+        // finally, update the screen :)
+        SDL_Flip(screen);
+
+        // time management
+        do
+        {
+            tps = SDL_GetTicks();
+        } while ( tps-tps_old < delay );
+        tps_old = tps;
+    } // end main loop
+
+    // all is well ;)
+    printf("Exited cleanly\n");
+    return 0;
+}