[RESOLU] Fonction RGB ou valeur couleur en hexadécimal ?

[TimProd]

Bonjour,

Dans un souci d'optimisation, les deux syntaxes suivantes sont-elles équivalentes en rapidité ?

Circle(100, 100, 10, RGB(255,0,0))

Circle(100, 100, 10, $0000FF)

Ma première idée est de penser que non, car RGB est une fonction ce qui induit un traitement supplémentaire.

Sauf qu'une fois compilés, les deux syntaxes sont peut-être équivalentes.

En vous remerciant par avance pour vos avis éclairés,

Cordialement

[GallyHC]

Bonjour,

Oui RGB() a forcement une perte de temps (négligeable) que de mettre la valeur en dur (hexa ou décimal). Si tu connais les valeurs et qu'elle ne bouge pas, les valeur hexa sont, je penses mieux. Alors pourquoi une fonction RGB(), tout simplement si tu as besoin de décomposé les valeurs avec des calculs de couleur.

La fonction permet simplement de pouvoir décomposé les composantes, quand tu doit faire par exemple un calcul de tes couleur pour un dégrader.

Un exemple : un truc que je me suis remis dessus, il y a peine hier en fait. Je fait un slider en "potentiomètre linaire" qui donne :



Pour le calcule des dégradés du "bouton", c'est beaucoup plus simple d'utiliser rgb(), car contre pour la règle du slider, les couleurs sont en dur (hexa), tout comme la couleur bleu en dessous des sliders.

Si tu me demande pourquoi faire le calcul des couleurs, cela est simple car cela me permet de pouvoir facilement changer la taille du bouton (un peu comme du vectoriel) et donc en exemple de faire les slider plus grand comme par exemple (en largueur de 64 pixels).



Cordialement,
GallyHC

[comtois]

Pour récupérer le code assembleur généré , tu peux lancer une compilation ainsi :

Code : Tout sélectionner

PbCompiler source.pb /commented 

Et tu obtiens

Code : Tout sélectionner

; a=RGB(255,0,0)
  PUSH   dword 0
  PUSH   dword 0
  MOV    eax,dword 255
  CALL   PB_RGB
  MOV    dword [v_a],eax

pour ce code source :

Code : Tout sélectionner

;RGB
a=RGB(255,0,0)

et

Code : Tout sélectionner

; a=$0000FF
  MOV    dword [v_a],255

pour ce code source

Code : Tout sélectionner

;Valeur directe
a=$0000FF

Il n'y a pas photo. Par contre RGB() est cross-plateforme.
Je ne suis pas sûr que tu obtiennes la même couleur sur windows , linux et MacOS avec ton $0000FF.

[GallyHC]

Bonjour,

comtois> PB décompose de la même façon dans tout les OS (mes sources donne toujours les mêmes couleurs en hexa). RGB est surtout utilise pour décomposé et ne pas devoir faire le calcul en décomposant en hexa justement les valeurs de RGB.

Code : Tout sélectionner

B  G  R
00 00 00

Sinon, tu fait en décomposant ton R (de 0 a FF) et pareil pour G B et tu rassemble de tout avec un "$", d'où la fonction et sont fonctionnement est utile.

Ce n'est pas un problème d'OS, c'est juste que la fonction est optimisé en assembler et ton exemple le prouve.

Cordialement,
GallyHC

[comtois]

Merci pour l'info, comme je n'utilise que windows, j'avais un doute.

[TimProd]

Merci à tous les deux.

C'est clair net et précis.

Il ne me reste plus qu'à modifier quelques lignes de codes en prenant garde d'en conserver d'autres pour les facilités offertes par RGB.

Bonne fin de week-end à tous.

[GallyHC]

Bonjour,

comtois> je suis content d'avoir pu te donné une info car je penses que tu as un niveau nettement supérieur a moi en PB (et même en programmation en général).

Alors je suis content ^^.

Cordialement,
GallyHC

[falsam]

Dans un souci d'optimisation, les deux syntaxes suivantes sont-elles équivalentes en rapidité ?

Comtois tu as raison, RGB fournit un code Assembleur plus important que si on fournissait la valeur Hexa de cette couleur.

Toutefois je ne suis pas si convaincu que qu'une optimisation de code en faveur de l'héxa est une réelle influence sur la rapidité d’exécution de ce code.

TimProd réalisant sont jeu en 2D, j'ai codé un petit programme de test qui se déroule en deux phases
- Phase A : Durant 30 secondes le code va compter et afficher des cercles en fournissant la valeur RGB.
- Phase B : Durant 30 secondes le code va compter et afficher des cercles en fournissant la valeur Hexadécimale.

Avant de lancer ce code, fermer toutes les applications afin que le processus de ce code ne soit pas ralenti par une autre application.

- Vous verrez en principe que le résultat n'est pas flagrant.

Code : Tout sélectionner

EnableExplicit

Enumeration Window
  #MainForm
EndEnumeration

Enumeration Sprite
  #Point
  #Test
EndEnumeration

Global Event
Global TestTime = 30000, StartTime, CurrentTime, TypeTest.s, TheEnd.b, Result.s
Global CountPointA, CountPointB
Global Font

Procedure GamePreload()
  CreateSprite(#Point, 40, 40, #PB_Sprite_AlphaBlending)
  CreateSprite(#Test, 400, 100, #PB_Sprite_AlphaBlending)
EndProcedure

Procedure GameUpdate(TypeTest.s)  
  ;Préparation des sprites
  StartDrawing(SpriteOutput(#Point))
  Box(0, 0, 40, 40, RGB(0, 0, 0))
  
  If TypeTest = "Test A" 
    CountPointA + 1
    Circle(20, 20, Random(20, 2), RGB(255, 0, 0))
    
  ElseIf TypeTest = "Test B"
    CountPointB + 1
    Circle(20, 20, Random(20, 2), RGB(255, 215, 0))
    
  EndIf
  
  StopDrawing()
  
  StartDrawing(SpriteOutput(#Test))
  Box(0, 0, 400, 100, RGB(0, 0, 0))
  DrawingFont(FontID(Font))
  DrawText(2, 2, TypeTest , RGB(255, 0, 0))
  StopDrawing()
  
  ;Affichage des sprites
  TransparentSpriteColor(#Point, RGB(0, 0, 0))
  DisplayTransparentSprite(#Point, Random(740, 10), Random(500, 10), Random(255, 20))
  
  DisplayTransparentSprite(#Test, 20, 550)
    
EndProcedure

Procedure GameStart()
  Protected Width = 800
  Protected Height = 600
  
  Font = LoadFont(#PB_Any, "Verdana", 30)
  
  If InitSprite() = 0 Or InitKeyboard() = 0 Or InitMouse() = 0 And InitSound() = 0
    MessageRequester("Error", "Sprite system can't be initialized", 0)
    End
  EndIf
  
  If OpenWindow(#mainform, 0, 0, Width, Height, "RGB or Hexa", #PB_Window_SystemMenu|#PB_Window_ScreenCentered)
    If OpenWindowedScreen(WindowID(#mainform), 0, 0, Width, Height)
      GamePreload()
    EndIf
  EndIf
  
  Repeat  
    Repeat
      Event = WindowEvent()
     
      Select event    
        Case #PB_Event_CloseWindow
          End
      EndSelect  
    Until event=0
    
    FlipBuffers()                
    ExamineKeyboard()
    ExamineMouse()
    
    If CountPointA = 0
      TypeTest = "Test A"  
      StartTime = ElapsedMilliseconds()
       
    ElseIf CountPointB = 0 And ElapsedMilliseconds()-StartTime > TestTime
      ClearScreen(RGB(0,0,0))
      TypeTest = "Test B"
      StartTime = ElapsedMilliseconds()
                  
    ElseIf CountPointB > 0 And ElapsedMilliseconds()-StartTime > TestTime
      TheEnd = #True
    EndIf
        
    GameUpdate(TypeTest)
  Until KeyboardPushed(#PB_Key_Escape) Or TheEnd = #True
EndProcedure

GameStart()

Result + "Nombre de points crées avec la fonction RGB : " + Str(CountPointA)+#CRLF$
Result + "Nombre de points crées avec la valeur hexa de la couleur: " + Str(CountPointB)+#CRLF$

MessageRequester("Resultat", Result)

[Ar-S]

@Falsam : J'ai un point de plus avec l'hex.

J'utilise plus souvent la valeur hexa, tout simplement parce que c'est moins long à écrire. RGB c'est en effet plus utile lors de la manip de couleur vue que les composantes se retrouvent avec les commandes Red()/Green()/Blue() la manipe est donc plus simple.
C'est plus RGBA() qui compte car il permet de gérer la couche alpha alors que la forme hexa $BBGGRR ne le permet pas, du moins je crois pas qu'on puisse faire $BBGGRRAA.

[falsam]

je crois pas qu'on puisse faire $BBGGRRAA.

L'héxa d'une couleur étant formaté à l'envers,la couche alpha se met au début.

Exemple pour le rouge : RGB(255, 0, 0) donnera en héxa $0000FF (Remarque que la composante Red est à la fin)

Juste pour rappel: La composante Alpha d'une couleur va permettre de définir la transparence d'une couleur variant de 0 (Transparent) à 255 (Opaque)

Une transparence à 120 donnera en Héxa 78. Ainsi RGB(255, 0, 0, 120) donnera $780000FF avec une valeur en héxa.

Un code pour finaliser ces explications.

Code : Tout sélectionner

Enumeration
  #Mainform
  #Canvas
EndEnumeration

Procedure Open_MainForm()
  OpenWindow(#Mainform, 0, 0, 500, 400, "New Form", #PB_Window_SystemMenu|#PB_Window_ScreenCentered)
  CanvasGadget(#Canvas, 0, 0, 500, 400)
  
  StartDrawing(CanvasOutput(#canvas))
  DrawingMode(#PB_2DDrawing_AlphaBlend)
  Box(10, 10, 200, 200, $FF00D7FF)
  Box(150, 150, 200, 200, $780000FF) 
  StopDrawing()
EndProcedure

Open_MainForm()

Repeat : Until WaitWindowEvent(10) = #PB_Event_CloseWindow

[Ar-S]

Je suis débile de pas avoir pensé que la valeur Alpha se foutait au début (comme le reste).
Faut dire que je trouve déjà chiant que l'hex ne propose que l'ordre BGR. Mon cerveau est conditionné à l'ordre RGB

[falsam]

J'ai fait la même confusion qui doit faire l'objet d'un post sur ce forum il me semble.

[GallyHC]

même erreur faite mainte fois par moi et donc j'évite de la refaire maintenant . j'utilise facilement photoshop pour les couleurs, que je dois forcement inversé (bon maintenant je le sais). ^^

[Fig]

Si on n'utilise pas de variable dans la fonction RGB(), le compilateur pourrait, aussi bien, simplement remplacer la fonction par son équivalent en dur.

Mais franchement, niveau optimisation, on s'en fout un peu: RGB() est suffisamment rapide pour que ce soit négligeable la plupart du temps.

[Lord Nelson]

Oui j'ai testé et c'est très légèrement L'héxa qui l'emporte mais c'est vraiment pas de beaucoup.