Discussion :

[CPPTryer]

Bonjour tout le monde, je code avec C# et Tao.Opengl,

J'ai tenté d'implémenter une fonction pour détecter les collisions de types pixels-perfects, mais l'algo à l'air de marcher que moyennement, defois il m'indique une collision Pixel-Perfect alors que les pixels de deux images ne se touchent pas et defois, ils se touchent mais il n'indique pas de collision.

Je suis sur qu'il doit y avoir un ennui au niv des offsets ptet, mais j'ai des difficultés à détecter les causes de cette gène^^

voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public static bool PixelPerfect(Rectangle Rectangle1, PTexture Texture1, Rectangle Rectangle2, PTexture Texture2)
        {
            if (PCollision.BoundingBox(Rectangle1, Rectangle2))
            {
                int i = 0;
                int j = 0;
 
                Rectangle RectangleOver = Rectangle1;
                RectangleOver.Intersect(Rectangle2);
 
                int xoffset1 = RectangleOver.X - Rectangle1.X; //if (xoffset1 < 0) xoffset1 = -xoffset1;
                int yoffset1 = RectangleOver.Y - Rectangle1.Y; //if (yoffset1 < 0) yoffset1 = -yoffset1;
 
                int xoffset2 = RectangleOver.X - Rectangle2.X; //if (xoffset2 < 0) xoffset2 = -xoffset2;
                int yoffset2 = RectangleOver.Y - Rectangle2.Y; //if (yoffset2 < 0) yoffset2 = -yoffset2;
 
                Console.WriteLine("Rectangle1 : {0}\nRectangle2 : {1}\nRectangleIntersect : {2}\nxoffset1 = {3} | yoffset1 = {4}\nxoffset2 = {5} | yoffset2 = {6}\n", Rectangle1, Rectangle2, RectangleOver, xoffset1, yoffset1, xoffset2, yoffset2);
 
                for (j = 0; j < RectangleOver.Height; ++j)
                {
                    for (i = 0; i < RectangleOver.Width; ++i)
                    {
                        if (Texture1.Image.PixelsAlpha[(i + xoffset1) + ((j + yoffset1) * Texture1.Image.Width)] == true
                            &&
                            Texture2.Image.PixelsAlpha[(i + xoffset2) + ((j + yoffset2) * Texture2.Image.Width)] == true)
                            return true;
                    }
                }
                return false;
            }
            else
                return false;
        }

Je n'ai pas mis de commentaire car je pense que le code est assez compréhensible. Merci d'avance pour votre aide.

[fearyourself]

Ok, j'avoue: je n'ai jamais fait de C# ou de Tao.Opengl mais bon...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
          RectangleOver.Intersect(Rectangle2);
 
                int xoffset1 = RectangleOver.X - Rectangle1.X; //if (xoffset1 < 0) xoffset1 = -xoffset1;
                int yoffset1 = RectangleOver.Y - Rectangle1.Y; //if (yoffset1 < 0) yoffset1 = -yoffset1;
 
                int xoffset2 = RectangleOver.X - Rectangle2.X; //if (xoffset2 < 0) xoffset2 = -xoffset2;
                int yoffset2 = RectangleOver.Y - Rectangle2.Y; //if (yoffset2 < 0) yoffset2 = -yoffset2;

Pourquoi avoir enlever les tests if? D'ailleurs, plus j'y pense et plus je pense que tu pourrais les enlever mais en faisant ta soustraction dans l'autre sens:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
          RectangleOver.Intersect(Rectangle2);
 
                int xoffset1 = Rectangle1.X - RectangleOver.X; 
                int yoffset1 = Rectangle1.Y - RectangleOver.Y;
 
                int xoffset2 = Rectangle2.X - RectangleOver.X;
                int yoffset2 = Rectangle2.Y - RectangleOver.Y;

Mais cela dépend comment sont gérer tes rectangles. Je suppose que (0,0) est le coin supérieur gauche et que la position de ton rectangle est aussi le coin supérieur gauche.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
             if (Texture1.Image.PixelsAlpha[(i + xoffset1) + ((j + yoffset1) * Texture1.Image.Width)] == true
                            &&
                            Texture2.Image.PixelsAlpha[(i + xoffset2) + ((j + yoffset2) * Texture2.Image.Width)] == true)
                            return true;

Est-ce que PixelsAlpha est le canal Alpha? Et il est mis en booléen? Donc c'est soit entièrement transparent ou entièrement opaque?

Ta fonction retourne false s'il n'y a pas de collision, or ce test dit:

"Si le canal Alpha de la première image est à vrai (donc transparent) et le canal de la deuxième image est à vrai (donc transparent) alors il y a une collision..."

Est-ce normal? Ahhh, peut-être que si la case est à vrai, alors le pixel est à dessiner... Faut vérifier je suppose.

Voilà, c'est des pistes mais c'est un début,
Jc

[CPPTryer]

Merci de ton intervention, lorsque tu as évoqué le fait que le rectangle prenait pour origine le coin supérieur gauche, je me suis souvenu que la structure fonctionnait ainsi mais que mes coordonnées pour l'affichage opengl, elles avaient une origine en bas à gauche, ce qui donnait un décalage au niveau du rectangle d'intersection
++

[fearyourself]

Merci de ton intervention, lorsque tu as évoqué le fait que le rectangle prenait pour origine le coin supérieur gauche, je me suis souvenu que la structure fonctionnait ainsi mais que mes coordonnées pour l'affichage opengl, elles avaient une origine en bas à gauche, ce qui donnait un décalage au niveau du rectangle d'intersection
++

De rien, bonne programmation!

Saches que tu peux facilement te débrouiller pour que opengl mette aussi l'origine en haut à gauche. C'est nettement plus pratique d'avoir la même représentation.

Jc