Messages

1

Fenêtrage / Re: Création de deux fenêtres problème d'évènements.

« le: Janvier 05, 2019, 01:22:00 pm »

Tout d'abord, il manque une boucle d'évènement pour la fenêtre w1.

Une erreur que les gens font souvent est d'oublier de mettre une boucle d'évènements, car ils n'en ont pas besoin (ils utilisent les entrées temps réel à la place, typiquement). Mais sans gestion d'évènement la fenêtre ne sera pas réactive ; en effet, la boucle d'évènement a deux rôles : en plus de fournir les évènements à l'utilisateur, elle permet à la fenêtre de traiter ses évènements internes, ce qui est impératif a son bon fonctionnement.

Quelle plateforme utilises-tu ? Je n'arrive pas à reproduire le problème sur Ubuntu.

2

Général / Re: Delete qui fait planter le programme

« le: Mai 11, 2018, 12:35:24 am »

Le problème est que destroy appelle le destructeur de l'instance via un delete qui lui-même appelle destroy.

Je recommande de stocker l'instance dans un std::unique_ptr, ce qui libérera la mémoire automatiquement.

3

Graphique / Re: Besoin d'aide pour un calcul d'intersection..

« le: Août 04, 2017, 09:48:07 pm »

Je ne sais pas si tu veux plus d'explications sur comment faire ou pourquoi ça marche, mais dans la cas où tu demandes comment faire concrètement, j'ai bidouillé un programme d'exemple pour afficher le point d'intersection de deux segments et déplacer les extrémités des segments à la souris.

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

float det(const sf::Vector2f& v1, const sf::Vector2f& v2)
{
    return v1.x * v2.y - v1.y * v2.x;
}

float dot(const sf::Vector2f& v1, const sf::Vector2f& v2)
{
    return v1.x * v2.x + v1.y * v2.y;
}

float squaredLength(const sf::Vector2f& v)
{
    return dot(v, v);
}

float squaredDistance(const sf::Vector2f& v1, const sf::Vector2f& v2)
{
    return squaredLength(v2 - v1);
}

bool lineLine(const sf::Vector2f& A, const sf::Vector2f& B, const sf::Vector2f& C, const sf::Vector2f& D, sf::Vector2f& intersection)
{
    sf::Vector2f AB = B - A,
                 CD = D - C,
                 AC = C - A;

    float d = det(AB, CD);
    if(d)
    {
        intersection = A + det(AC, CD) / d * AB;
        return true;
    }
    else
        return false;
}

bool segmentSegment(const sf::Vector2f& A, const sf::Vector2f& B, const sf::Vector2f& C, const sf::Vector2f& D, sf::Vector2f& intersection)
{
    if(lineLine(A, B, C, D, intersection))
    {
        float u = dot(intersection - A, B - A),
              v = dot(intersection - C, D - C);
        return 0.f <= u && u <= squaredDistance(A, B) &&
               0.f <= v && v <= squaredDistance(C, D);
    }
    else
        return false;
}

int main()
{
    sf::CircleShape interCircle(16.f);
    interCircle.setOrigin(interCircle.getRadius(), interCircle.getRadius());
    interCircle.setFillColor(sf::Color::Transparent);
    interCircle.setOutlineColor(sf::Color::Red);
    interCircle.setOutlineThickness(1.f);

    sf::CircleShape draggedCircle = interCircle;
    draggedCircle.setOutlineColor(sf::Color::Green);
    sf::Vector2f* dragged = nullptr;

    // segments
    sf::VertexArray va(sf::Lines, 4);
    sf::Vector2f& A = va[0].position,
                & B = va[1].position,
                & C = va[2].position,
                & D = va[3].position;
    A = {100, 100};
    B = {700, 300};
    C = {200, 500};
    D = {600, 200};

    sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
    window.setFramerateLimit(60.f);

    while(window.isOpen())
    {
        sf::Event event;
        while(window.pollEvent(event))
        {
            if(event.type == sf::Event::Closed)
                window.close();
            else if(event.type == sf::Event::MouseMoved)
            {
                sf::Vector2f mouse = window.mapPixelToCoords(sf::Vector2i(event.mouseMove.x, event.mouseMove.y));

                if(sf::Mouse::isButtonPressed(sf::Mouse::Left) && dragged)
                {
                    *dragged = mouse;
                    draggedCircle.setPosition(*dragged);
                }
                else
                {
                    sf::Vector2f* closest = std::min({&A, &B, &C, &D},
                    [&mouse](const sf::Vector2f* v1, const sf::Vector2f* v2)
                    {
                        return squaredDistance(*v1, mouse) < squaredDistance(*v2, mouse);
                    });

                    if(squaredDistance(mouse, *closest) <= draggedCircle.getRadius() * draggedCircle.getRadius())
                    {
                        dragged = closest;
                        draggedCircle.setPosition(*dragged);
                    }
                    else
                        dragged = nullptr;
                }
            }
        }

        sf::Vector2f intersection;
        bool found = segmentSegment(A, B, C, D, intersection);
        if(found)
            interCircle.setPosition(intersection);

        window.clear();
        window.draw(va);
        if(dragged)
            window.draw(draggedCircle);
        if(found)
            window.draw(interCircle);
        window.display();
    }

    return EXIT_SUCCESS;
}
 

4

Graphique / Re: Besoin d'aide pour un calcul de trajectoire...

« le: Août 01, 2017, 08:06:13 pm »

Si tu veux utiliser la méthode avec les pentes des droites, tu devras gérer le cas particulier de droites verticales. Je t'encourage à utiliser le déterminant, c'est moins bancal.

Sinon, il y a une erreur dans le calcul de PP2. (Trop de copier-coller !)

5

Général / Re: Boutons à la même position

« le: Juillet 26, 2017, 11:03:27 pm »

Bonjour,
Si je comprends bien, lors d'un clic sur les boutons, le test sur le premier bouton est vérifié et donc variable2 devient true. Juste après, le test sur le deuxième bouton est vérifié aussi (comme il est à la même position que le premier bouton) et variable2 est vrai comme on vient de l'affecter, donc l'action associée au deuxième bouton est effectuée.
Je vois plusieurs solutions:
- Faire le test sur le deuxième bouton avant celui sur le premier bouton.
- Utiliser un seul bouton et un booléen qui indique s'il y a déjà été cliqué. Pourquoi avoir deux boutons au même endroit ?

6

Graphique / Re: Besoin d'aide pour un calcul de trajectoire...

« le: Juillet 26, 2017, 01:44:10 am »

Je ne vois pas à quoi servent leurs " x " à tout bout de champs dans leurs explications...

C'est souvent la notation anglo-saxonne pour le produit vectoriel. Dans le post de Stack Overflow que j'ai cité, c'est défini au début comme la longueur (algébrique) de ce produit vectoriel, ce qui n'est autre que le déterminant de deux vecteurs dans le plan (cf. Wikipédia).

Voici plus d'explications sur mon code :
On a deux paires de points qui définissent les droites (A,B) et (C,D). On suppose donc A différent de B et C différent de D.
On suppose aussi que les droites se coupent en un point P (ie. les droites ne sont pas parallèles).
Le point P est sur la droite (AB) donc il existe un nombre réel alpha tel que
        P = A + alpha AB
Il suffit de calculer la valeur de alpha pour connaître P. Pour cela, il nous faut une équation : on va exploiter le fait que P est sur la droite (CD).
C'est là qu'intervient le déterminant. On exprime que le vecteur CP est colinéaire au vecteur CD par
        det(CP, CD) = 0
Pour faire apparaître alpha dans l'équation, on commence par faire apparaître AP en remplaçant CP dans l'expression par AP - AC.
        det(AP - AC, CD) = 0
Par linéarité du déterminant, det(AP - AC, CD) = det(AP, CD) - det(AC, CD), donc on obtient
        det(AP, CD) = det(AC, CD)
En remplaçant AP par alpha AB, on trouve
        alpha det(AB, CD) = det(AC, CD)
On a supposé que les droites (AB) et (CD) ne sont pas parallèles donc le déterminant det(AB, CD) est non nul.
        alpha = det(AC, CD) / det(AB, CD)
On a donc trouvé l'expression de P.
        P = A + det(AC, CD) / det(AB, CD) * AB

J'espère que ça t'aide.

7

Graphique / Re: Besoin d'aide pour un calcul de trajectoire...

« le: Juillet 24, 2017, 08:39:17 pm »

@Kernel panik, attention aux divisions par zéro!

Pour le calcul d'intersection entre deux droites, il me semble plus lisible d'utiliser le déterminant.
J'avais fait comme ça dans un prototype en python. Il ne devrait pas être trop compliqué de l'adapter en C++.

def det(A, B):
    return A.x * B.y - A.y * B.x

def line_line_intersection(line0, line1):
    A, B = line0
    C, D = line1

    AB = B - A
    CD = D - C
    AC = C - A

    return A + det(AC, CD) / det(AB, CD) * AB

Il y a une explication ici : https://stackoverflow.com/a/565282

Comme il y a une division, il faut vérifier au préalable que det(AB, CD) est non nul, c'est à dire que les droites ne sont pas parallèles.

En partant de ça, tu peux tester l'intersection du rayon avec chaque côté du rectangle.

8

Graphique / Re : Problème d'angle de tir / Déplacement du projectile en fonction de la souris.

« le: Mars 01, 2017, 08:40:42 pm »

Attention à l'orientation des angles. Le repère de l'écran (x vers la droite et y vers le bas) implique que les angles attendus par les fonctions trigonométriques sont orientés dans le sens des aiguilles d'une montre.

bullet[i].move(cos(angBul) * 4, -sin(angBul) * 4);

Ici le signe moins devant le sinus est en trop.

Autre problème, dans le cacul de l'orientation des projectiles, il faut considérer le vecteur bul->mouse et pas mouse->bul comme cela est fait ici :

atan2(bul.getPosition().y - mousePosition.y,
      bul.getPosition().x - mousePosition.x)

9

Général / Re : Problème de collisions

« le: Août 19, 2016, 08:03:04 pm »

Il me semble que ta fonction vérifie que chaque sommet du polygone convexe A est contenu dans le polygone convexe B.
Cela est équivalent à tester si A est inclus dans B, pas à tester l'intersection.

Je crois que le plus simple serait de se baser sur le Separating Axis Theorem.

10

Discussions générales / Re : Norme SFML

« le: Août 07, 2016, 05:01:01 pm »

Cette page y est consacrée : http://www.sfml-dev.org/style.php

11

Général / Re : Chute violente de FPS incompréhensible

« le: Juillet 09, 2016, 03:23:53 pm »

Bonjour et bienvenue sur le forum.

Le problème ici est que tu utilises à la fois setVerticalSyncEnabled et setFramerateLimit. Il ne faut pas le faire. Cela est expliqué dans le tutoriel Ouvrir et gérer une fenêtre SFML.

12

Général / Re : Physique de saut

« le: Avril 07, 2016, 01:22:30 pm »

Il me semble que le problème vient surtout de la façon dont tu positionnes ta View.
Tu appelles la méthode move alors que les formules te donnent un position.
Tu dois choisir : soit utiliser la méthode move et indiquer effectivement un déplacement, soit utiliser setCenter avec une position.

13

Général / Re : No such file or directory ????!!!!!

« le: Août 18, 2015, 03:49:21 pm »

Dans l'onglet "Search Directories" > "Compiler", il faut probablement remplacer "C:\MinGW\include\SFML" par "C:\MinGW\include".
Quand tu inclus SFML/Graphics.hpp, le compilateur cherche en vain le fichier "C:/MinGW/include/SFML/SFML/Graphics.hpp" au lieu de "C:/MinGW/include/SFML/Graphics.hpp".
Bref, il fallait suivre le tuto.

14

Général / Re : Tilemap isométrique ? Fail !

« le: Août 13, 2015, 07:22:12 pm »

Le compilateur te dit que des opérateurs sont appelés sur des variables dont les types ne le permettent pas. En effet, tileSize est un Vector2u. Je pensais que tu manipulais des float. Cela est plus pratique pour pouvoir assigner des vecteurs à des positions d'objets de la SFML.
Le plus simple est d'utiliser un Vector2f à la place mais si tu veux garder un Vector2u, alors il va falloir faire des conversions à gogo.

15

Général / Re : Tilemap isométrique ? Fail !

« le: Août 13, 2015, 05:46:48 pm »

Cool ! Pourquoi mon programme fait ça ?!

Ton programme fait ça parce que c'est ce que tu lui demandes.

Ton calcul de position est mauvais. Si je comprends bien ta façon d'indexer les tuiles, tu te rendras compte en faisant un croquis que tu voulais probablement écrire ceci dans ta boucle:

sf::Vector2f position(x / 2 * tileSize.x, y * tileSize.y);
if(x % 2) //Impair
    position += tileSize / 2.f;

quad[0].position = position;
quad[1].position = position + sf::Vector2f(tileSize.x, 0);
quad[2].position = position + tileSize;
quad[3].position = position + sf::Vector2f(0, tileSize.y);