Messages

286

Général / Re : Gravityé et collisions

« le: Mai 01, 2013, 04:05:39 pm »

Y , l'axe vertical de ton entité.
regarde ceci : http://www.tonypa.pri.ee/tbw/

287

Suggestions de nouvelles fonctionnalités / Re : Tablette et force feedback

« le: Mai 01, 2013, 03:21:36 pm »

voila une idée de cadeau , une tablette graphique , il te reste 23 jours pour le mettre sur ta liste

288

Suggestions de nouvelles fonctionnalités / Re : Tablette et force feedback

« le: Mai 01, 2013, 02:40:52 pm »

Dans le cadre d'un logiciel de dessin par exemple , dessiner à la main dans un renderTexture , profité du hardware , etc... , tu vas me dire que c'est trop spécifique à ce genre d'application , mais regarde le support du ftp , par exemple , c'est spécifique aussi , pourtant tu le supportes  

289

Suggestions de nouvelles fonctionnalités / Re : Tablette et force feedback

« le: Mai 01, 2013, 02:29:26 pm »

Si tu comptes te lançer dans le support du mobile ( android ) , le force-feedback pourrais être assimilé au vibreur de la tablette/téléphone.

Pour l'instant je n'ai aucun plan pour le support des vibrations. Je ne pense pas que ça arrivera dans un futur proche.

2°eme point , est ce que tu t'es penché sur le support des tablettes graphique , sytle wacom ? comme par exemple récupérer facilement la pression du stylet , l'angle , etc...

Aucunement. Je suis assez étranger à ce genre de périphérique à vrai dire. Je n'en aurais même pas un pour tester.
Question bête : à part dans les logiciels de dessin, à quoi peuvent servir ces périphériques ? Ou, dit autrement, est-ce réellement pertinent pour SFML ?

SFML est une librairie multimédia , de fait , une tablette graphique est un périphérique qui permet de dessiner , donc oui , pour moi c'est pertinent , c'est un périphérique au même titre qu'une souris, sous windows , c'est l'api wintab , pour le reste ( linux, mac) aucune idée.

290

Suggestions de nouvelles fonctionnalités / Tablette et force feedback

« le: Mai 01, 2013, 01:29:33 pm »

Bonjour Laurent , tout d'abord , félicitation pour la sortie de la v2 , le portail à vraiment de la gueule , j'aime bien.  Bon, on en avais déjà discuter , mais je préfère relancer la discussion la dessus concernant le support du Force FeedBack , je t'avais dis à l'époque que sdl 1.3 le supportait , à priori multi-plateformes.
Si tu comptes te lançer dans le support du mobile ( android ) , le force-feedback pourrais être assimilé au vibreur de la tablette/téléphone.
2°eme point , est ce que tu t'es penché sur le support des tablettes graphique , sytle wacom ? comme par exemple récupérer facilement la pression du stylet , l'angle , etc...

@++

291

Projets SFML / Re : MOBA 2D

« le: Avril 22, 2013, 11:44:16 am »

Bonjour, ton annonce est très mal formulé, peu de chance de voir du monde grossir les rangs :

- Pas une maquette qui fonctionne
- l'impression que rien n'est fait

tu recherches des grapheux (problème de beaucoup de programmeur), mais si par hasard un programmeur réseau de préférence par par là,  il est le bienvenu , ça ne fait pas sérieux ,et cela montre déjà des lacunes dans les compétences.

ATTENTION, nous recherchons des personnes motivées qui n'abandonneront pas au bout de 2 semaines. C'est un projet de longue haleine mais qui arrivera à son terme.

Affirmer ce genre de chose est prétentieux et montre que rien n'est fait , de plus ça fait quoi si un graphiste n'a que 5 jours pour contribuer ?
ne le prend pas mal , c'est le ressenti que j'ai eu en lisant ton post.

292

Graphique / Re : freeze & app.Draw()

« le: Septembre 28, 2012, 10:05:23 pm »

Oui c'est une question de performance , le codage doit avoir un problème qui est imperceptible avec un pc de bureau plus puissant.

Comment est écrit ta classe d'animation ?
Comment l'invoque tu dans ton main() ?

Sans code, personne ne pourra te répondre.

293

Projets SFML / Re : Zloxx II - Un Jump'n'Run d'action

« le: Juillet 20, 2012, 02:49:31 am »

Je veux dire un léger relief. donc moins plat
pour le contrôle , c'est pas que c'est mou , le problème c'est que le héros n'a pas de phase d’accélération & de décélération. le héros n'a pas d'énergie cinétique.

Sonic , par exemple. quand tu n'appuis plus sur la touche avancé , il continue un peu de courir.

@++

294

Projets SFML / Re : Zloxx II - Un Jump'n'Run d'action

« le: Juillet 14, 2012, 05:34:54 pm »

je viens de testé , c'est sympa, J'aime bien les musiques , en revanche :

Graphismes trop "plat" , ça manque de profondeur. les anims ne sont pas top. Je te conseil de te rapprocher d'un graphiste
Au niveau du contrôle, le héros est un peu "mou" , d'ailleurs c'est quoi comme bête le héros ? 


 

295

Discussions générales / Re : Recherche d'une GUI mais pas seulement...

« le: Juillet 12, 2012, 11:47:31 pm »

Désolé du HS. c'est ma dernière "dérive" du sujet.

je dirais juste qu'il est conscient/réaliste.

y'a une diff entre un truc testé et éprouvé depuis de longue années (genre Qt) et une lib dév par un seul homme sur son temps libre (et utilisé à bcp moins grande échelle).
suffit de voir les bugs (notamment ceux de la 1.6).

Peut être, mais le dev n'est pas non plus un lapin de six semaines , sinon on ne serais pas là.
entre pas robuste / pas fiable et quelques bugs , y a une différence, les mots ont un sens.

Il faut bien se rendre compte qu'une version 2.0 c'est le tout début d'un nouveau cycle. Les versions suivantes, jusqu'à la 3.0, ne serviront qu'à corriger et améliorer. Du coup 2.0 sera la moins robuste et fiable de la série, forcément. Faut pas voir ça comme une version ultime, mais comme un premier jet d'une nouvelle API

Je préfère lire cela Encore désolé du hs, j'allais pas faire un topic pour ça.
 

296

Discussions générales / Re : Recherche d'une GUI mais pas seulement...

« le: Juillet 12, 2012, 12:23:26 am »

La 2.0 va sortir donc ne sera ni fiable ni robuste (la 2.9 le sera peut-être, dans quelques années).

 

Heu... , c'est une blague ? qu'entend tu par là ? tu doutes de ton propre code ? je ne te suis pas du tout là. 

297

Graphique / Re : sf::Text qui ne s'affiche pas

« le: Juin 20, 2012, 01:44:13 pm »

tu peut pas faire un zip de ton code et le mettre en ligne ? ( par mp si tu préfères... ) , car à part spéculer sur d'éventuelles erreurs , on ne peut rien faire.

298

Projets SFML / SFML 2.0 physique verlet

« le: Juin 19, 2012, 03:39:22 pm »

Un code qui traînait sur mon disque dur qui simule l'attraction des corps entre eux , autant en faire profité tout le monde , je ne sais plus d'ou je m'en suis inspiré , peu importe , il fonctionne plutôt bien avec la sfml 2.0 ( testé sous Linux x64 ).

#include <math.h>
#include <cstdlib>
#include <vector>
#include <iostream>
#include <time.h>

#include <SFML/Graphics.hpp>
#include <SFML/Window.hpp>


#define GENERATE_BODY  512


class Verlet
{
        public:
                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                Verlet()
                {
                        _position.x   = 0;
                        _position.y   = 0;
                        _lastPosition = _position;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                Verlet(const sf::Vector2f & pos)
                {
                        _position               = pos;
                        _lastPosition   = pos;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                void Update(float timeStep)
                {
                        sf::Vector2f temp = _position;
                        _position                += _position - _lastPosition + _acceleration * timeStep * timeStep  ;
                        _lastPosition     = temp;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                sf::Vector2f & GetPosition()
                {
                        return _position;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                void SetAcceleration(const sf::Vector2f & accel)
                {
                        _acceleration = accel;
                }

        protected:
                sf::Vector2f            _position;
                sf::Vector2f            _lastPosition;
                sf::Vector2f            _acceleration;

};

class CircleBody;

typedef struct CollideInfo CollideInfo;
struct CollideInfo
{
        float                   depth;
        sf::Vector2f    normal;
        CircleBody *    body;
};

class CircleBody :  public Verlet,
                                        public sf::CircleShape
{
        public:
                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                CircleBody()
                {
                        Verlet::_position.x     = 0.0f;
                        Verlet::_position.y     = 0.0f;
                        Verlet::_lastPosition.x = 0.0f;
                        Verlet::_lastPosition.y = 0.0f;
                        Verlet::_acceleration.x = 0.0f;
                        Verlet::_acceleration.y = 0.0f;
                        _updatable = false;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                CircleBody(const sf::Vector2f & pos, float radius, float state)
                {
                        _position               = pos;
                        _lastPosition   = pos;
                        _acceleration   = sf::Vector2f(0,0);
                        _radius                 = radius;
                        _mass                   = _radius * _radius;
                        _updatable              = state;

                        sf::CircleShape::setRadius(_radius);
                        sf::CircleShape::setPosition(_position);
                        sf::CircleShape::setFillColor(sf::Color(64,128,255,150));
                        sf::CircleShape::setOutlineColor(sf::Color(255,255,255,128));
                        sf::CircleShape::setOutlineThickness(2.0f);

                }
                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                float GetRadius()
                {
                        return _radius;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                void Update(float timeStep)
                {

                        if(_updatable == true)
                        {
                                Verlet::Update(timeStep);
                        }

                        sf::CircleShape::setPosition(sf::Vector2f(_position.x-_radius ,
                                                                                                          _position.y-_radius));
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                bool IsUpdatable()
                {
                        return _updatable;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                float GetMass()
                {
                        return _mass;
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                bool CheckCollide(CircleBody & other)
                {
                        if (&other != this)
                        {
                                sf::Vector2f temp;
                                temp = other.Verlet::GetPosition() - _position;
                                float dist = sqrt(temp.x * temp.x + temp.y * temp.y);

                                if(dist >= _radius + other.GetRadius())
                                {
                                        return false;
                                }

                                if( dist > 1e-08)
                                {
                                        temp.x  /= dist;
                                        temp.y  /= dist;
                                }


                                _collide.normal = temp;
                                _collide.depth  = _radius + other.GetRadius() - dist;
                                _collide.body   = &other;

                                if(_collide.depth<1e-08)
                       _collide.depth=1e-08;

                                return true;
                        }
                }

                ///////////////////////////////////////////////////////////////////////
                //
                //
                ///////////////////////////////////////////////////////////////////////
                void Collide(CircleBody & other)
                {
                        if (_updatable == true)
                        {
                                if(other.IsUpdatable() == true)
                                {
                                        sf::Vector2f move;
                                        move = _collide.normal * _collide.depth * 0.5f;

                                        _position -= move;
                                        other.Verlet::GetPosition() += move;
                                }
                                else
                                {
                                        sf::Vector2f move;
                                        move = _collide.normal * _collide.depth;
                                        _position -= move;
                                }
                        }
                }



        protected:

                float           _mass;
                float           _radius;
                bool            _updatable;
                CollideInfo     _collide;
};






int main()
{


 sf::VideoMode desktop = sf::VideoMode::getDesktopMode();
 sf::RenderWindow window(desktop, "SFML window", sf::Style::Fullscreen);
 window.setFramerateLimit(60);

 sf::Font font = sf::Font::getDefaultFont();

 sf::Text text("SIMPLE BODY TEST BY CPL.BATOR\nARROW KEY TO SCROLL\nPAGE UP/DOWN TO ZOOM");
 text.setFont(font);
 text.setCharacterSize(240);
 text.setStyle(sf::Text::Bold);
 text.setColor(sf::Color(255,128,64,128));
 text.scale(0.25f,0.25f);

 float zoomFactor = 1.0f;
 bool zoomUp      = false;
 bool zoomDown    = false;
 sf::View view;
 view = window.getView();



 std::vector<CircleBody*>       body;

 srand ( time(NULL) );

 for (int i=0; i < GENERATE_BODY / 2; ++i)
 {

        int px = -(rand() % 500 + 1) + (rand() % 1500 + 1);
        int py = -(rand() % 500 + 1) + (rand() % 1500 + 1);

        CircleBody * b = new CircleBody(sf::Vector2f((float)px,(float)py), rand() % 25 + 1, true);
        body.push_back(b);

 }


 float                  ghost_radius = 15.0f;
 sf::Vector2i           ghost_position;
 sf::CircleShape        ghost;

 ghost.setRadius(ghost_radius);
 ghost.setFillColor(sf::Color(255,255,255,64));




 while (window.isOpen())
 {

    sf::Event event;
    while (window.pollEvent(event))
    {

        if (event.type == sf::Event::Closed)
            window.close();

        if(event.type == sf::Event::MouseWheelMoved)
        {
                if(event.mouseWheel.delta > 0)
                {
                 ghost_radius += 1;
                }
                else if(event.mouseWheel.delta < 0)
                {
                 ghost_radius -= 1;
                }
        }

        if(event.type == sf::Event::MouseButtonReleased)
        {
                if (event.mouseButton.button == sf::Mouse::Left)
            {
           
                sf::Vector2f   pos = window.convertCoords(sf::Vector2i(ghost_position.x - ghost_radius ,ghost_position.y - ghost_radius));

                CircleBody * b = new CircleBody(pos, ghost_radius , true);
                                body.push_back(b);
            }
        }




    }

        ghost.setRadius(ghost_radius);

        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Left))
        {
          view.move(-10.0f,0.0f);
        }
        else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Right))
        {
          view.move(10.0f,0.0f);
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Up))
        {
          view.move(0.0f,-10.0f);
        }
        else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Down))
        {
          view.move(0.0f,10.0f);
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::PageUp))
        {
                zoomFactor += 0.01;
                zoomUp          = true;
                zoomDown        = false;
        }
        else if (sf::Keyboard::isKeyPressed(sf::Keyboard::PageDown))
        {
                zoomFactor -= 0.01;
                zoomUp          = false;
                zoomDown        = true;
        }


        if ( zoomUp == true && zoomFactor > 1.0f)
        {
                zoomFactor -= 0.005f;
                if (zoomFactor <= 1.0 )
                {
                    zoomFactor = 1.0f;
                        zoomUp = false;
                }
        }

        if ( zoomDown == true && zoomFactor < 1.0f)
        {
                zoomFactor += 0.005f;
                if (zoomFactor >= 1.0 )
                {
                        zoomFactor = 1.0f;
                        zoomDown = false;
                }
        }

        if (zoomFactor > 1.2f)
                zoomFactor = 1.2f;

        if (zoomFactor < 0.8f)
                zoomFactor = 0.8f;


        if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
        {
          window.close();
        }



        std::vector<CircleBody*>::iterator itA;
        std::vector<CircleBody*>::iterator itB;



        for(itA = body.begin(); itA<body.end(); ++itA)
        {

                CircleBody * bodyA = *itA;
                sf::Vector2f accel(0.0f,0.0f);
                // Update position
                for(itB = body.begin(); itB<body.end(); ++itB)
                {

                        CircleBody * bodyB = *itB;

                        if(*itA != *itB)
                        {



                                sf::Vector2f temp = bodyB->Verlet::GetPosition() - bodyA->Verlet::GetPosition();

                                float dist = sqrt(temp.x * temp.x + temp.y * temp.y);
                                if(dist>1e-08)
                                {
                                 temp.x /= dist;
                                 temp.y /= dist;
                                }

                                dist = bodyA->GetMass() * bodyB->GetMass() * 0.001f / (dist * dist);

                                temp *= dist;

                                accel += temp;

                        }
                }

                bodyA->Verlet::SetAcceleration(accel);



                // Check for collision
                for(itB = body.begin(); itB<body.end(); ++itB)
                {
                        CircleBody * bodyB = *itB;

                        if(*itA != *itB)
                        {
                                if (bodyA->CheckCollide(*bodyB) == true)
                                {
                                        bodyA->Collide(*bodyB);
                                }
                        }
                }

                        bodyA->Update(2);

        }


        view.zoom(zoomFactor);
        window.setView(view);

    ghost_position   =  sf::Mouse::getPosition(window);
    sf::Vector2f   v = window.convertCoords(sf::Vector2i( ghost_position.x - ghost_radius ,ghost_position.y - ghost_radius));


     ghost.setPosition(v.x, v.y);





    window.clear(sf::Color(2,4,8,255));

        window.draw(text);

        std::vector<CircleBody*>::iterator it;
        for(it = body.begin(); it<body.end(); ++it)
        {
                window.draw(**it);
        }

        window.draw(ghost);

    window.display();
 }



return 1;
}
 

299

Graphique / Re : sf::Text qui ne s'affiche pas

« le: Juin 18, 2012, 11:06:08 pm »

bizarre... tu peut faire un packatage près à compilé ?
le peu de code que tu as mis ne donne pas de piste, le problème dois venir d'autre part.

300

Graphique / Re : sf::Text qui ne s'affiche pas

« le: Juin 18, 2012, 10:31:12 pm »

 sf::Texture texture;
    texture.loadFromFile("image.png");
    m_sprite.setTexture(texture);
    m_sprite.setPosition(SCREEN_W/2, SCREEN_H/2);

Tu fait une erreur avec le sprite, tu ne gardes pas la texture , elle est détruite à la fin de ton constructeur.
ca ne m'étonnerais pas que ton erreur vienne de là, car là, y a bug.