Import electric project

sdl1/electricField/ElecField.cpp

@@ -0,0 +1,134 @@
+#include "ElecField.h"
+
+#define WHILE_LIMIT 10000
+
+struct Charge
+{
+    bool sign ; // true si positive
+    Sint16 value ;
+    Uint16 nbOut ;
+
+    double x ; // entre 0.0 et 1.0
+    double y ;
+};
+
+ElecField::ElecField() : m_graph( 0x0 )
+{
+    //ctor
+}
+
+ElecField::~ElecField()
+{
+    if ( !m_graph ) SDL_FreeSurface( m_graph ) ;
+}
+
+
+void ElecField::renderGraph( int w, int h )
+{
+    // Détruit vieille surface si existante
+    if ( !m_graph ) SDL_FreeSurface( m_graph ) ;
+
+    // Créé nouvelle surface
+    m_graph = SDL_CreateRGBSurface( SDL_HWSURFACE, w, h, 32, 0, 0, 0, 0 );
+
+    // Variables
+    double pas( 0.01 ) ;
+    double x, y, angle ;
+
+    // Affichage
+    for ( std::vector<Charge>::iterator it( m_chList.begin() ); it != m_chList.end(); it ++ )
+    {
+        // Cercle qui localise la charge
+        if ( it->sign )
+            circleRGBA( m_graph, Sint16( it->x * w ), Sint16( it->y * h ), it->value, 255, 255, 0, 255 );
+        else
+            circleRGBA( m_graph, Sint16( it->x * w ), Sint16( it->y * h ), -it->value, 0, 128, 255, 255 );
+
+        // Ligne de champ qui partent d'une charge +
+        if ( it->sign )
+        {
+            for ( int s(0); s < it->nbOut; s ++ )
+            {
+                angle = s * 2 * M_PI / it->nbOut ;
+
+                x = it->x + it->value * std::cos( s ) / w ;
+                y = it->y + it->value * std::sin( s ) / h ;
+
+                drawLineFrom( x, y );
+            }
+        }
+    }
+}
+
+SDL_Surface* ElecField::getGraph() const
+{
+    return m_graph ;
+}
+
+
+void ElecField::addCharge(int value, double x, double y, Uint16 nbOut)
+{
+    m_chList.push_back( { value > 0, value, nbOut, x, y } );
+}
+
+void ElecField::drawLineFrom( double x, double y )
+{
+    double pas( 0.001 );
+    double xp, yp ;
+
+    int w( m_graph->w );
+    int h( m_graph->h );
+
+    Uint32 incr(0) ;
+
+    while ( x > 0.0 && x < 1.0 && y > 0.0 && y < 1.0 && incr < WHILE_LIMIT )
+    {
+        // Incrémentation
+        incr ++ ;
+
+        // Mémoriser l'endroit actuel
+        xp = x ;
+        yp = y ;
+
+        // Calculer la composante de la force
+        double fx( 0.0 );
+        double fy( 0.0 );
+        double r;
+
+        for ( std::vector<Charge>::iterator it( m_chList.begin() ); it != m_chList.end(); it ++ )
+        {
+            // Calcul de la distance
+            r = std::sqrt( ( it->x - x )*( it->x - x ) + ( it->y - y )*( it->y - y ) );
+
+            // Il faut sortir de la boucle si la ligne se termine sur une charge -
+            if ( !it->sign && std::abs( r ) < -it->value / ( std::sqrt( h*h + w*w ) ) )
+                break ;
+
+            // Calcul des forces
+            fx += ( x - it->x ) * it->value / r / r / r ;
+            fy += ( y - it->y ) * it->value / r / r / r ;
+        }
+
+
+        // Normaliser
+        r = std::sqrt( fx * fx + fy * fy );
+        fx /= r ;
+        fy /= r ;
+
+        // Il faut sortir de la boucle si la force est trop faible
+        if ( r < 0.5 )
+            break ;
+
+        // Discrétiser
+        fx *= pas ;
+        fy *= pas ;
+
+        // Bouger
+        x += fx ;
+        y += fy ;
+
+        // Dessiner
+        //lineRGBA( m_graph, xp * m_graph->w, yp * m_graph->h, x * m_graph->w, y * m_graph->h, 255, 255, 255, 255 );
+        pixelRGBA( m_graph, x * m_graph->w, y * m_graph->h, 255, 255, 128, 255 );
+    }
+}

sdl1/electricField/ElecField.h

@@ -0,0 +1,36 @@
+#ifndef ELECFIELD_H
+#define ELECFIELD_H
+
+#include <iostream>
+#include <vector>
+#include <cmath>
+
+#include <SDL.h>
+#undef main
+
+#include "Gfx/SDL_gfxPrimitives.h"
+
+struct Charge;
+
+class ElecField
+{
+    /// Méthodes
+    public:
+        ElecField();
+        virtual ~ElecField();
+
+        void renderGraph( int w, int h );
+        SDL_Surface* getGraph() const;
+
+        void addCharge(int value, double x, double y, Uint16 nbOut = 24 );
+
+    protected :
+        void drawLineFrom( double x, double y );
+
+    /// Attributs
+    protected:
+        SDL_Surface* m_graph;
+        std::vector< Charge > m_chList;
+};
+
+#endif // ELECFIELD_H

sdl1/electricField/main.cpp

@@ -0,0 +1,80 @@
+#include <iostream>
+#include <SDL.h>
+
+#include "ElecField.h"
+
+int main ( int argc, char** argv )
+{
+    /// [1] Démarrage
+    // [1.1] Démarrages SDL
+    if ( SDL_Init( SDL_INIT_VIDEO ) < 0)
+    {
+        std::cout << "Impossible d'initialiser la SDL: " << SDL_GetError() << std::endl;
+        return 1;
+    }
+
+    // [1.2] Préparation de fermeture
+    atexit(SDL_Quit);
+
+    // [1.3] Para-fenêtre
+    SDL_WM_SetCaption("Electric Field Pointer", 0);
+
+    /// [2] Préparation des composants
+    // [2.1] Préparation de la fenêtre
+    SDL_Surface* screen = SDL_SetVideoMode(800, 800, 32,
+                                           SDL_HWSURFACE|SDL_DOUBLEBUF);
+    if ( !screen )
+    {
+        std::cout << "Unable to set 640x480 video: " << SDL_GetError() << std::endl;
+        return 1;
+    }
+
+    // [2.2] Préparation
+    ElecField monChamp;
+
+    monChamp.addCharge( 20, 0.20, 0.5, 200 );
+    monChamp.addCharge( -1, 0.5, 0.5 );
+
+    monChamp.renderGraph( 800, 800 );
+
+    // [2.3] Préparation du texte
+
+
+    /// [3] Boucle principale
+    bool done = false;
+    while (!done)
+    {
+        // [3.1] Gestion évènements
+        SDL_Event event;
+        while (SDL_PollEvent(&event))
+        {
+            switch (event.type)
+            {
+            case SDL_QUIT:
+                done = true;
+                break;
+            case SDL_KEYDOWN:
+                if (event.key.keysym.sym == SDLK_ESCAPE)
+                    done = true;
+                break;
+            } // end switch event type
+        } // end of message processing
+
+        // [3.2] Calculs
+
+        // [3.3] Dessin des composants
+        SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 128, 130));
+
+        SDL_BlitSurface( monChamp.getGraph(), 0x0, screen, 0x0 );
+        rectangleRGBA(screen, 5, 5, 795, 795, 255, 255, 0, 255);
+
+        SDL_Flip(screen);
+    } //fin bcl principale
+
+    ///[4] Destruction des composants
+    SDL_FreeSurface(screen);
+
+
+    std::cout << "Aucune erreur détectée." << std::endl;
+    return 0;
+}