Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Membre à l'essai
    [DevIL] Aide DevIL pour chargement texture Opengl
    Bonjour,
    Pour un projet en Opengl et en C# j'utilise DevIL pour charger mes images. Les images se charge bien et s'affiche bien. Lorsque j'ai voulu creer une fonction pour tester les collisions de type "Pixel-Perfect", j'ai souhaité récupérer l'octet alpha de chaque pixel de chaque image que je stocke dans un tableau de byte. N'ayant pas trouvé d'exemple clair sur internet j'ai essayé d'y aller à taton. Voici pour l'instant mon code(celui qui charge l'image) :

    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
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
     
    public void AddFromFile(string File, string Name)
            {
                try
                {
                    Il.ilInit();
     
                    Ilut.ilutRenderer(Ilut.ILUT_OPENGL);
     
                    Il.ilOriginFunc(Il.IL_ORIGIN_LOWER_LEFT);
                    Il.ilEnable(Il.IL_ORIGIN_SET);
     
                    Il.ilEnable(Il.IL_FILE_OVERWRITE);
     
                    Il.ilSetInteger(Il.IL_FORMAT_MODE, Il.IL_RGBA);
                    Il.ilEnable(Il.IL_FORMAT_SET);
     
                    int ImageId = ++this.LastOpenglIdUsed;
     
                    Il.ilGenImages(1, out ImageId);
                    Il.ilBindImage(ImageId);
     
                    if (!Ilut.ilutGLLoadImage(File))
                    {
                        MessageBox.Show("Could not open file, " + File + ", exiting.");
                    }
                    else
                    {
                        int Width = Il.ilGetInteger(Il.IL_IMAGE_WIDTH);
                        int Height = Il.ilGetInteger(Il.IL_IMAGE_HEIGHT);
                        int Depth = Il.ilGetInteger(Il.IL_IMAGE_DEPTH);
                        int Bpp = Il.ilGetInteger(Il.IL_IMAGE_BITS_PER_PIXEL);
     
                        IntPtr Pixels = Il.ilGetData();
     
                        byte[] PixelArray = new byte[Width * Height * 4];
                        Marshal.Copy(Pixels, PixelArray, 0, Width * Height * 4);
                        this.Add(new PImage(this.LastOpenglIdUsed, Width, Height, PixelArray), Name);
                        Il.ilDeleteImages(1, ref ImageId);
                    }
                }
                catch
                {
                    throw;
                }
            }

    Pourriez vous me dire si dans PixelArray, j'obtiens bien les 4octets de chaque pixels de l'image ?
    Ensuite pour mon test de collision je vais devoir regarder tous les 4octets pour obtenir la valeur de l'octet alpha de chaque pixel ? Quel valeur aura-t'il si le pixel est transparent ? si il est plein ?
    Merci d'avance
    @+++

  2. #2
    Rédacteur

    Pourriez vous me dire si dans PixelArray, j'obtiens bien les 4octets de chaque pixels de l'image ?
    A priori oui (y a qu'à tester pour en être certain).

    Ensuite pour mon test de collision je vais devoir regarder tous les 4octets pour obtenir la valeur de l'octet alpha de chaque pixel ?
    Ce serait plus compliqué, plus lent et plus coûteux en mémoire que de ne garder qu'un tableau de booléens stockant l'état de chaque pixel (collidable ou traversable).

    Quel valeur aura-t'il si le pixel est transparent ? si il est plein ?
    L'alpha désigne l'opacité. Donc :
    Alpha 0 transparent
    Alpha 255 opaque

###raw>template_hook.ano_emploi###