Go-SDL2

1) Introduction

Après avoir installer le compilateur go avec la bibliothèque "Simple DirectMedia Layer" (SDL 2) comme indiqué ici, nous allons décrire les commandes graphiques :

2) Package, initialisation et fermeture

import "fmt"     Pour les sorties consoles : Print(), Println(), Fprintf()
import "os"   Pour les commandes systèmes: Exit(), Stderr
import "time"   Pour gérer le temps: Sleep()

 
import "github.com/veandco/go-sdl2/sdl"     Pour dessiner
import "github.com/veandco/go-sdl2/img"   Pour traiter les images jpg et png
import "github.com/veandco/go-sdl2/ttf"   Pour insérer du texte dans les graphiques

Une initialisation ainsi qu'une libération une fois l'utilisation terminée, est necessaire :

var e error      
e := sdl.Init(sdl.INIT_EVERYTHING)   Initialise tout.
if e != nil {
    fmt.Fprintf(os.Stderr, "Erreur à l'initialisation sdl: %s\n", e)
    os.Exit(1)
}		   En cas d'échec de l'initialisation, affichez le message d'erreur et arréter le programme.
img.Init(img.INIT_JPG | img.INIT_PNG)   Initialise le traitement d'image jpg et png
sdl.SetHint(sdl.HINT_RENDER_SCALE_QUALITY, "1")   Fixe une qualité de mise à l'échelle pour les images (de 0 à 2). La valeur par défaut est 0 a.k.a. échantillon de pixels le plus proche.
...    
img.Quit()   Libère le traitement d'image
sdl.Quit()   Libère SDL


Créer une fenêtre w
w, e := sdl.CreateWindow(s,x,y,Dx,Dy,m)
Variable
Type
Description
Exemple
w
*sdl.window
 Fenêtre
e
error
 Erreur
s
string
 Titre
"Essai"
x
int32
 Position x
sdl.WINDOWPOS_UNDEFINED
y
int32
 Position y
sdl.WINDOWPOS_UNDEFINED
Dx
int32
 Largeur
640
Dy
int32
 Hauteur
480
m
uint32
 Mode
sdl.WINDOW_SHOWN
Libérer la fenêtre w
  w.Destroy()

3) Graphique sans rendu (sans traitement spécifique de la carte grapique)

Créer une surface s d'une fenêtre w
s, e := w.GetSurface()
Variable
Type
Description
w
*sdl.Window
 Fenêtre
e
error
 Erreur
s
*sdl.Surface
Surface
Libérer la surface s
s.Free()

 

Package sdl

import "github.com/veandco/go-sdl2/sdl"
 

Variables
synoptiques
Type
r,g,b
uint8
n,x,y,Dx,Dy
int32
s
string
e
error
m,c
uint32
w
*sdl.Window
s
*sdl.Surface
r
sdl.Rect
R
*sdl.Renderer
Type
Description
sdl.Rect
 Rectangle, sdl.Rect{X,Y,W,H}
*sdl.Window
 Fenêtre
*sdl.Surface
 Surface d'une fenêtre, en mémoire RAM.
*sdl.Renderer
 Surface d'une fenêtre, en mémoire carte graphique.
 
Fonction
Description
Type du résultat
e = sdl.Init(m) Initialise. Choisir pour m la constante sdl.INIT_EVERYTHING.
error
w, e = sdl.CreateWindow(s, x, y, Dx, Dy, m) Crée la fenêtre w de titre s de position x,y et de largeur hauteur Dx,Dy avec le mode m.
Choisir pour m la constante sdl.WINDOW_SHOWN.
*sdl.Window,
error
s, e = w.GetSurface() Crée la surface s de la fenêtre w.
*sdl.Surface,
error
r = sdl.Rect{x,y,Dx,Dy} Crée un rectancle de position x,y et de largeur hauteur Dx,Dy
sdl.Rect
c = sdl.MapRGB(s.Format, r, g, b) Calcule la couleur c selon le format de la surface s et les niveaux r,g,b.
uint32
s.FillRect(nil,c) Efface la surface s avec la couleur c.
s.FillRect(&r, c) Efface le rectancle r avec la couleur c.
w.UpdateSurface() Affiche ce qui a été dessiné sur la surface s.  
     
     
     
     
     
     
     

 

 

 

 

Dominique Mabboux-Stromberg

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2) Créer une fenêtre (sans accélération graphique)

package main    
import "fmt"  
import "os"  
import "time"  
import "github.com/veandco/go-sdl2/sdl"  
import "github.com/veandco/go-sdl2/img"    
import "github.com/veandco/go-sdl2/ttf"    
     
func main() {
  
    e := sdl.Init(sdl.INIT_EVERYTHING)   Initialise tout.
    if e != nil {
        fmt.Fprintf(os.Stderr, "Erreur à l'initialisation sdl: %s\n", e)
        os.Exit(1)
    }		   En cas d'échec de l'initialisation, affichez le message d'erreur et arréter le programme.
    w, e := sdl.CreateWindow(   Crée une fenêtre w.
        "Rectancles fixes",   Titre de la fenêtre.
        0,   Position x.
        0,   Position y.
        640,   Largeur.
        480,   Hauteur.
        sdl.WINDOW_SHOWN   Fenêtre visible.
    )  
    s, e := w.GetSurface()   Crée une surface s de la fenêtre w.
     s.FillRect(nil, sdl.MapRGB(s.Format, 255, 0, 0))
   Si nil est utilisé comme premier argument, la surface entière est coloriée avec la couleur r, g, b.
    r := sdl.Rect{100, 60, 300, 200}   Crée un rectangle r (position x, position y, Largeur ,Hauteur).
    s.FillRect(&r, sdl.MapRGB(s.Format, 0, 255, 0))   Dessine le rectangle r sur la surface s avec la couleur r, g, b.
    s.FillRect(   Dessine le rectangle (0,0,200,200) avec la couleur (0, 255, 0).
        &sdl.Rect{0, 0, 150, 120},  
        sdl.MapRGB(s.Format, 0, 255, 0)
  
        )  
    w.UpdateSurface()   Affiche ce qui a été dessiné sur la surface.
    time.Sleep(time.Second * 5)   Attendre 5 secondes.
     
     
    w.Destroy()   Supprime la fenêtre.
    sdl.Quit()   Libère SDL2.
}    

3) Créer une seconde fenêtre (avec accélération graphique)

    w2, e := sdl.CreateWindow(     Crée une fenêtre w2.
        "Dynamique",   Titre de la fenêtre.
        642,   Position x.
        0,   Position y.
        640,   Largeur.
        480,   Hauteur.
        sdl.WINDOW_SHOWN   Fenêtre visible.
    )  
    r2, e := sdl.CreateRenderer(w2, -1, sdl.RENDERER_ACCELERATED)   Crée le rendu r2 de la fenêtre w2.
    B := true    
    var P sdl.Event    
    var x int32 = 0    
    var v int32 = 1    
    for B {   Boucle principale.
        for P = sdl.PollEvent(); P != nil; P = sdl.PollEvent() {   Gère les évènements. La touche d’Echap sort de la boucle.
            switch t := P.(type) {    
            case *sdl.QuitEvent:    
                B = false    
            case *sdl.KeyboardEvent:    
                if t.Keysym.Sym == sdl.K_ESCAPE {    
                    B = false    
                }    
            }    
        }    
        r2.SetDrawColor(0, 0, 0, 255)   Fixe la couleur (rouge, vert, bleu, alpha).
        r2.Clear()   Efface la fenêtre avec la couleur spécifiée.
        r2.SetDrawColor(0, 255, 0, 255)    
        r2.FillRect(&sdl.Rect{0, 0, 200, 200})    
        r2.SetDrawColor(0, 0, 255, 255)    
        x = x + v    
        if (x+100) >= 640 || x < 0 {    
            v = -v    
        }    
        r2.DrawRect(&sdl.Rect{x, 100, 100, 100})    
        r2.Present()   Affiche ce qui a été dessiné sur la surface.
        time.Sleep(time.Millisecond * 10)    
    }    
     
     
    r2.Destroy()    
    w2.Destroy()    

4) Créer une troisième fenêtre (avec accélération graphique) et insertion d'une image

Mettre une image jpg /home/dmabboux/persona.jpg

    w3, _ := sdl.CreateWindow(     Crée une fenêtre w3.
        "Image tournante",   Titre de la fenêtre.
        0,   Position x.
        484,   Position y.
        600,   Largeur.
        600,   Hauteur.
        sdl.WINDOW_SHOWN   Fenêtre visible.
    )    
    r3, _ := sdl.CreateRenderer(w3, -1, sdl.RENDERER_ACCELERATED)   Crée le rendu r3 de la fenêtre w3.
    r3.Clear()   Efface le rendu r3.
    sdl.SetHint(sdl.HINT_RENDER_SCALE_QUALITY, "1")   fixe une qualité de mise à l'échelle pour les images (de 0 à 2). La valeur par défaut est 0 a.k.a. échantillon de pixels le plus proche.
    I, e := img.Load("/home/dmabboux/persona.jpg")   Charger l’image en mémoire I.
    if e != nil {
        fmt.Fprintf(os.Stderr, "Erreur au chargement de l'image jpg: %s\n", e)
        os.Exit(4)
    }		   En cas d'échec du chargement de l'image, affichez le message d'erreur et arréter le programme.
    L := I.W
    H := I.H		   Largeur L et hauteur H de l'image I. (Une fois I.Free() exécuténous n'avons plus accès à I.W et I.H)
    tx, _ := r3.CreateTextureFromSurface(I)   Création d'une texture tx avec accélération matérielle (mémoire Ram --> mémoire carte graphique)
    I.Free()   Libération de la mémoire Ram I.
    for P = sdl.PollEvent(); P != nil; P = sdl.PollEvent() { }   Vidage de la file des évènements
    var a float64 = 0.0   Angle a initialisé à 0.0
    B = true    
    for B {   Boucle principale.
        for P = sdl.PollEvent(); P != nil; P = sdl.PollEvent() {   Gère les évènements. La touche d’Echap sort de la boucle.
            switch t := P.(type) {    
            case *sdl.QuitEvent:    
                B = false    
            case *sdl.KeyboardEvent:    
                fmt.Printf(    
 "[%d ms] \ttype:%d\tsym:%d %c\tmodifiers:%d\tstate:%d\trepeat:%d\n",    
                    t.Timestamp,    
                    t.Type,    
                    t.Keysym.Sym,    
                    t.Keysym.Sym,    
                    t.Keysym.Mod,    
                    t.State,    
                    t.Repeat    
                )    
                if t.Keysym.Sym == sdl.K_ESCAPE {    
                    B = false    
                }    
            }    
        }    
        r3.SetDrawColor(255, 255, 55, 255)    
        r3.Clear()    
        r3.Copy(   Copie d'image.
            tx,   La texture source.
            nil,   La partie de la texture à copier, sous forme d'un rectangle. nil indique que toute l'image est à copier.
            &sdl.Rect{0, 0, 50, 50}   Le lieu ou sera copié cette partie, sous forme d'un rectangle.
        )    
        a += 1.0
            if a > 360.0 {
            a = 0
        }		    
        r3.CopyEx(   Copie d'image avec davantage d'options,
            tx,   La texture source.

            nil,

   La partie de la texture à copier, sous forme d'un rectangle. nil indique que toute l'image est à copier.
            &sdl.Rect{100, 100, L, H},   Le lieu ou sera copié cette partie, sous forme d'un rectangle.
            a,   Angle en degrés d'inclinaison de la partie.
            nil,   Point autour duquel tourne la partie. nil indique le point centrale de la partie.
            sdl.FLIP_HORIZONTAL   Inverse droite et gauche (sdl.SDL_FLIP_VERTICAL inverse haut et bas, sdl.FLIP_NONE laisse inchangé).
        )    
        r3.Present()    
        time.Sleep(time.Millisecond * 10)    
    }    
     
     
    tx.Destroy()   Libère la mémoire de la texture tx
    img.Quit()   Ferme la librairie sdl_image
    r3.Destroy()    
    w3.Destroy()