Dégradé.h , librairie de degrade.

Télécharger le projet
Commenter

Description

Dégradé rgb dégradé balayant le spectre de la lumiere blanche, dégradé a deux couleur, dégradé circulaire ... Voici un résumé de ce dont ma librairie est capable. Il y a trois famille de dégradé permettant chacune 13 types de dégradé. il y a aussi pour deux d'entre elle la possibilité de réglé la luminosité du dégradé.

vous pouvez toujours regarder la capture décran pour voir ces exemples de dégradés.

je vous donne la source ci dessous mais elle est disponible aussi dans le zip.
Zip indispensable pour avoir l'aide relative a l'utilisation de la librairie.

Source / Exemple : 


;librairie dégradé.h par Kerrigan
;Remerciement a Seregon qui ma motivé meme s'il ne le sait pas
;Et a Chang-Fu qui m'a fait le cahier des charges. 
;Et a Kolibot qui m'a trouvé le jaune !!!

alias deg_rgb { 
  if ( !$window($2)) { halt }
  var %itr = 1,%r = 0,%g = 0,%b = 0, %1 = $int($calc($3 /3)) , %2 = $calc(2* %1),%3 = $3,%i = $calc(3*255/ $3),%w = $4, %x = $5,%y = $6,%l = $7
  while ( %itr < %3 ) { 
    if ( %itr <= %1 ) { inc %r %i }
    elseif ( %itr >= %1 ) && ( %itr < %2 ) { dec %r %i | inc %g %i } 
    elseif ( %itr >= %2 ) { dec %g %i  | inc %b %i }
    if ( %itr >= $calc(%3 -4) ) { goto end | var %g = 0 | if ( i isin $1 ) { var %r = 255 } | else { var %b = 255 } }
    ;je laisse volontairement ce bout de code maladroit j'ai encore du travail a faire dessus ... a votre envie de transformer ou pas...
    ;le parser plus bas pourrait regler ces erreurs mais une chose a la fois ... comme ça , ça fonctionne très bien en plus
    if ( $1 = -d ) { drawline -r $2 $rgb(%r,%g,%b) $iif($8,$8,$calc(%l +1)) $calc(%itr + %x) %y $calc(%itr + %x) $calc(%w + %y) | inc %itr %l }
    elseif ( $1 = -di ) { drawline -r $2 $rgb(%b,%g,%r) $iif($8,$8,$calc(%l +1)) $calc(%itr + %x) %y $calc(%itr + %x) $calc(%w + %y) | inc %itr %l }
    elseif ( $1 = -b) { drawline -r $2 $rgb(%r,%g,%b) $iif($8,$8,$calc(%l +1)) %x $calc(%itr + %y) $calc(%x + %w) $calc(%itr + %y) | inc %itr %l }
    elseif ( $1 = -bi) { drawline -r $2 $rgb(%b,%g,%r) $iif($8,$8,$calc(%l +1)) %x $calc(%itr + %y) $calc(%x + %w) $calc(%itr + %y) | inc %itr %l }
    elseif ( $1 = -a ) { drawdot -r $2 $rgb(%r,%g,%b) $calc(%3 - %itr + $8) %x %y | inc %itr %l }
    elseif ( $1 = -ai ) { drawdot -r $2 $rgb(%b,%g,%r) $calc(%3 - %itr + $8) %x %y | inc %itr %l }
    elseif ( $1 = -r ) { drawdot -r $2 $rgb(%r,%g,%b) $calc(%3 - %itr) %x %y | inc %itr %l }
    elseif ( $1 = -ri ) { drawdot -r $2 $rgb(%b,%g,%r) $calc(%3 - %itr) %x %y | inc %itr %l }
    :end
    inc %itr 
  }
  if ( a isin $1 ) { drawdot -r $2 $rgb(255,255,255) $calc($8 +1) %x %y | inc %itr %l }
  ;ça serait peut etre intéréssant de pouvoir changer la couleur de la tache centrale. Affaire a suifre
}

alias deg_sp { 
  if ( !$window($2)) { halt }
  var %itr = 1,%r = 0,%g = 0,%b = 0, %1 = $int($calc($3 /5)) , %2 = $calc(2* %1),%3 = $calc(3* %1),%i = $calc(5*255/ $3),%5 = $3,%4 = $calc(4* %1),%w = $4, %x = $5,%y = $6,%l = $7
  while ( %itr < %5 ) { 
    if ( %itr <= %1 ) { inc %r %i }
    if ( %itr >= %1 ) && ( %itr < %2 ) { inc %g %i } 
    if ( %itr >= %2 ) && ( %itr < %3 ) { dec %r %i | inc %b %i }
    if ( %itr >= %3 ) && ( %itr < %4 ) { dec %g %i }
    if ( %itr >= %4 ) { inc %r %i }
    if ( %itr >= $calc(%5 -2) ) { goto end | var %g = 0,%r = 255,%b = 255 }
    ;meme remarque que plus haut, c'est maladroit mais je pourrais avoir besoin de ce type de syntaxe après ...
    if ( $1 = -d ) { drawline -r $2 $rgb(%r,%g,%b) $iif($8,$8,$calc(%l +1)) $calc(%itr + %x) %y $calc(%itr + %x) $calc(%w + %y) | inc %itr %l }
    elseif ( $1 = -di ) { drawline -r $2 $rgb(%b,%g,%r) $iif($8,$8,$calc(%l +1)) $calc(%itr + %x) %y $calc(%itr + %x) $calc(%w + %y) | inc %itr %l }
    elseif ( $1 = -b) { drawline -r $2 $rgb(%r,%g,%b) $iif($8,$8,$calc(%l +1)) %x $calc(%itr + %y) $calc(%x + %w) $calc(%itr + %y) | inc %itr %l }
    elseif ( $1 = -bi) { drawline -r $2 $rgb(%b,%g,%r) $iif($8,$8,$calc(%l +1)) %x $calc(%itr + %y) $calc(%x + %w) $calc(%itr + %y) | inc %itr %l }
    elseif ( $1 = -r ) { drawdot -r $2 $rgb(%r,%g,%b) $calc(%5 - %itr) %x %y | inc %itr %l }
    elseif ( $1 = -ri ) { drawdot -r $2 $rgb(%b,%g,%r) $calc(%5 - %itr) %x %y | inc %itr %l }
    elseif ( $1 = -a ) { drawdot -r $2 $rgb(%r,%g,%b) $calc(%5 - %itr + $8) %x %y | inc %itr %l }
    elseif ( $1 = -ai ) { drawdot -r $2 $rgb(%b,%g,%r) $calc(%5 - %itr + $8) %x %y | inc %itr %l }
    :end
    inc %itr
  }
  if ( a isin $1 ) { drawdot -r $2 $rgb(255,255,255) $calc($8 +1) %x %y | inc %itr %l }
}

alias max { var %m = 0,%itr = 1 | while ( $ [ $+ [ %itr ] ] ) { if ( $abs($calc($ifmatch)) >= %m ) { var %m = $ifmatch } | inc %itr } | return %m }
alias move { if ( % [ $+ [ $1 ] ] > $2 ) { dec % $+ $1 %i } | elseif ( % [ $+ [ $1 ] ] < $2 ) { inc % $+ $1 %i } | return % [ $+ [ $1 ] ] }
;l'alias move est la clé de voute de cette partie du code. C'est elle qui permet de faire les itération pour incrémenter la valeur des couleurs.

alias deg_c { 
  if ( !$window($2)) { halt }
  set %r $3
  set %g $4
  set %b $5
  var %3 = $9,%itr = 1,%x = $11,%y = $12,%w = $10
  set %i $calc($max($2 - $5,$3 - $6,$4 - $7) / $9)
  while ( %itr < %3 ) { 
    if ( $1 = -d ) { drawline -r $2 $rgb($move(r,$6),$move(g,$7),$move(b,$8)) $iif($13,$13,1) $calc(%itr + %x) %y $calc(%itr + %x) $calc(%w + %y) }
    elseif ( $1 = -b) { drawline -r $2 $rgb($move(r,$6),$move(g,$7),$move(b,$8)) $iif($13,$13,1) %x $calc(%itr + %y) $calc(%x + %w) $calc(%itr + %y) }
    elseif ( $1 = -r ) { drawdot -r $2 $rgb($move(r,$6),$move(g,$7),$move(b,$8)) $calc(%3 - %itr) %x %y }
    elseif ( $1 = -a ) { drawdot -r $2 $rgb($move(r,$6),$move(g,$7),$move(b,$8)) $calc(%3 - %itr + $13) %x %y }
    inc %itr
  }
  if ( a isin $1 ) { drawdot -r $2 $rgb(255,255,255) $calc($13 +1) %x %y }
  unset %r %b %g %i
}

;dégradé centré, meme syntaxe que deg_c
alias -l m { var %m = 0,%itr = 1 | while ( $ [ $+ [ %itr ] ] ) { if ( $abs($calc($ifmatch)) >= %m ) { var %m = $ifmatch } | inc %itr } | return %m }
alias -l m1 { var %t = 1 | while ( %t <= 5 ) { var %v = $ [ $+ [ %t ] ] | if ( % [ $+ [ %v ] ] > $ [ $+ [ $calc(%t +1) ] ] ) { dec % $+ %v %i  } | elseif ( % [ $+ [ %v ] ] < $ [ $+ [ $calc(%t +1) ] ] ) { inc % $+ %v %i } | inc %t 2 } }
alias -l m2 { var %t = 1 | while ( %t <= 5 ) { var %v = $ [ $+ [ %t ] ] | if ( % [ $+ [ %v ] ] < $ [ $+ [ $calc(%t +1) ] ] ) { dec % $+ %v %i  } | elseif ( % [ $+ [ %v ] ] > $ [ $+ [ $calc(%t +1) ] ] ) { inc % $+ %v %i } | inc %t 2 } }
alias -l parse { var %t = 1 | while ( $ [ $+ [ %t ] ] ) { var %v = $ifmatch | if ( % [ $+ [ %v ] ] > 255 ) { set % $+ %v 255 } | elseif ( % [ $+ [ %v ] ] < 0 ) { set % $+ %v 0 } | inc %t } }
;un parser était nécessaire car des erreurs sont apparues pendant la compagne de test.
;il regarde si les alias m1 ou m2 renvoient des valeur abérantes et si c'est le cas il les corrige.

alias deg_r { 
  var %3 = $9,%itr = 1,%x = $11,%y = $12,%w = $10
  set %r $3
  set %g $4
  set %b $5
  set %i $calc($m($2 - $5,$3 - $6,$4 - $7) / ( 2* $9))
  while ( %itr < %3 ) { 
    if ( %itr <= $calc(%3 /2) ) { $m1(r,$6,g,$7,b,$8) }
    else { $m2(r,$6,g,$7,b,$8) }
    $parse(r,g,b)
    if ( $1 = -d ) { drawline -r $2 $rgb(%r,%g,%b) $iif($13,$13,1) $calc(%itr + %x) %y $calc(%itr + %x) $calc(%w + %y) }
    elseif ( $1 = -b) { drawline -r $2 $rgb(%r,%g,%b) $iif($13,$13,1) %x $calc(%itr + %y) $calc(%x + %w) $calc(%itr + %y) }
    elseif ( $1 = -r ) { drawdot -r $2 $rgb(%r,%g,%b) $calc(%3 - %itr) %x %y }
    elseif ( $1 = -a ) { drawdot -r $2 $rgb(%r,%g,%b) $calc(%3 - %itr + $13) %x %y }
    inc %itr
  }
  if ( a isin $1 ) { drawdot -r $2 $rgb(255,255,255) $calc($13 +1) %x %y }
  unset %i %r %g %b
}

;/deg_sp2 -[b,d,a,r] @fenetre longueur largeur x y arrondis r.g.b_depart r.g.b_1 ... r.g.b_N ... r.g.b_arrivée
;permet de faire un dégradé , en balayant un spectre que l'on a soit meme définit
;vous trouverez des exemples dans deg_sp1.jpg

alias g { return $gettok($gettok(%c,$1,32),$2,46) }
alias -l m3 { var %n = 1 | while ( %n <= 5 ) { var %v = $ [ $+ [ %n ] ] | if ( % [ $+ [ %v ] ] > $ [ $+ [ $calc(%n +1) ] ] ) { dec % $+ %v %i  } | elseif ( % [ $+ [ %v ] ] < $ [ $+ [ $calc(%n +1) ] ] ) { inc % $+ %v %i } | inc %n 2 } }
alias -l max2 { var %m = 0,%p = 1 | while ( $gettok($1-,%p,44) ) { if ( $abs($ifmatch) >= %m ) { var %m = $ifmatch } | inc %p } | return %m }
alias deg_sp2 { 
  var %q = 1
  %c = $8-
  while ( %q <= $calc($gettok(%c,0,32) -1)) { 
    var %valeur = %valeur $calc($g(%q,1) - $g($calc(%q +1),1)) $+ , $+ $calc($g(%q,2) - $g($calc(%q +1),2)) $+ , $+ $calc($g(%q,3) - $g($calc(%q +1),3)) $+ $iif(%q != $calc($gettok(%c,0,32) -1),$chr(44))
    inc %q
  }
  var %itr = 1,%t = 1,%x = $5,%y = $6,%w = $4,%1 = $3,%c1 = $gettok(%c,0,32)
  set %i $calc( %c1 * $max2(%valeur) / $3)
  while ( %itr <= $calc(%c1 -1)) {
    set %r1 $g(%itr,1)
    set %g1 $g(%itr,2)
    set %b1 $g(%itr,3)
    var %r2 = $g($calc(%itr +1),1),%g2 = $g($calc(%itr +1),2),%b2 = $g($calc(%itr +1),3)
    while ( %t <= $calc(%itr * $calc(%1 / %c1 )) ) { 
      $m3(r1,%r2,g1,%g2,b1,%b2)
      $parse(r1,g1,b1)
      if ( $1 = -d ) { drawline -r $2 $rgb(%r1,%g1,%b1) $iif($7 != 0,$7,1) $calc(%x + %t) %y $calc(%t + %x) $calc(%w + %y) }
      elseif ( $1 = -b) { drawline -r $2 $rgb(%r1,%g1,%b1) $iif($7 != 0,$7,1) %x $calc(%t + %y) $calc(%x + %w) $calc(%t + %y) }
      elseif ( $1 = -r ) { drawdot -r $2 $rgb(%r1,%g1,%b1) $calc(%1 - %t) %x %y }
      elseif ( $1 = -a ) { drawdot -r $2 $rgb(%r1,%g1,%b1) $calc(%1 - %t + $7) %x %y }
      inc %t
    }
    inc %itr
  }
  if ( a isin $1 ) { drawdot -r $2 $rgb(255,255,255) $calc($7 +1) %x %y }
  unset %r1 %g1 %b1 %i
}

Conclusion :


Il y a un petit bug , je le repete souvent dans l'aide mais les luminosité non entiere ne marche pas tres bien ( pas du tout meme on obtient un spectre canelé)
et pour certain indice de luminosité, le lisage du rectangle disparait.

Cela peut etre reglé en arrondissant le rectangle (voir l'aide en image) mais passer certain indice le problème réaparait.

je me suis dis aussi que je pourrais permettre des spectre de dégradé personnalisé , mais je ne vois pas encore trop comment faire et je très occupé en ce moment donc j'ai pas trop le temps. Je vous promets d'y reflechir.

le code est a copié dans les remotes ou alors loader le texte présent dans le zip (dégradé.hkr)

premier uptadate
ajoute de deg_r qui permet de faire des donuts dégradé :)
(un premier pas vers la texture en mirc ...)

deuxieme update
ajout d'un parser car les alias m1 et m2 renvoyaient des valeurs abérantes pour certains dégradés.

troisieme update
ajout du spectre personnaliser pour faire des dégradéq avec des spectres avec le nombres de couleurs que l'on veut.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Kerrigan)