Auteur Sujet: HS pixelartdisk  (Lu 26096 fois)

0 Membres et 1 Invité sur ce sujet

j'm'attaque à des distorsions d'espace cette fois



souvent utile le fade par sinus :
function fad_sin(dis,marg,fad){
  var map=0;
  if(dis<=marg){map=1}
  else if(dis>marg && dis<marg+fad)
   {map = (1-Math.sin(( (dis-marg)/fad -.5)*PI))/2}
  return map;
}

j'me tate , j'ai grave envie de testé des micros métaball pour généré des chaos 3d,
de toute façon ont aura besoin de cette approche pour recréé des objets complexe !

beaucoup de domaine observé procède de la même façon quant il s'agit de transmettre une information lointaine , ils là fond passé , personne ne bouge plusse que sont petite espace, mais l'énergie le message lui est transmit d'un lieux lointain à ici sans même que jamais aucun des habitants de ce lieux lointain n'est eux à jamais sortir de leur lieux ! ça c'est fascinant,  l'information elle voyage , grâce à ce procédés elle peut aller partout,

si je faisais des particules en grande quantité localiser dans un damier , puis dispersais des messages leurs donnant des ordres ciblé non ciblé ,
information ?? !
information est existentiel, elle est la présence !
un message peut être contenu et rendu statique durant long temps ou récupéré, perdu,
le message fourni ou pas sont origine sont auteur, , il peut dire comment est le lieux,
un message est rarement envoyer au hasard , il y a correspondance vers un lieux connu ,
l’intérêt d'un système est de faire parvenir le massage vèrs le plus gros centre de connexion qui devrait connaitre tout les lieux c'est là où çà deviens dingue, ,
l'idée est de réunir les individus par la correspondance soit une façon de se rendre présent l'un envers l'autre quelque soit l'espace qui les sépares ,
dans mon cas ça serait pour chercher des corrélations entre particules qui les feraient voyager physiquement, un réseau d'information
0_0
qu'est ce que les ténèbres peuvent avoir à dire au ténèbres ?

ont aurait tendance à comprendre que les espaces veulent se coller pour avoir un réseau totale et rapide ...
pourtant ont connait bien des spécimens qui ne désir pas être densifier , c'est pourquoi bien que dépendant d'un réseau ils cherche des lieux inoccupé ! là est l’expansion,
pour être bien il faut être dans un espace adapté  , ce qui est grand et désert ,
et pour exister il faut être en correspondance avec le monde,

créé un espace reviens à créé des lieux, un lieux connait sont nom et détiens une liste plutôt courte des noms des lieux qu'il connait ,
un lieux ne vas pas dans un autre lieux pour donné sont message, il vas dans un poste qui s'occuper d'une liste de lieux environnant assez grande ,
un poste transmet alors le message à un des lieux qu'il possède si il s'agit d'un d'eux sinon il donne aux autres poste environnant qu'il connait,

tendisse que le message aura atteint ça cible des doubles continuerons de parcourir toutes les postes il se peut même qu'il tourne en boucle dans le réseaux ,
c'est pourquoi un bureau général qui connait toutes les postes serait utile, un noyaux est utile, individualiser le monde,
ce noyaux connait toute les postes, le nom du lieux est connu seulement de la poste, et le nom des postes seulement du noyaux , c'est pourquoi il faut connaitre le nom des postes (ville) , dans le cas d'un lieux seul une duré de vie du courrier évite là récursion infini ,
évidement toute les postes doivent connaitre la poste vers laquelle rediriger le courrier pour aller au noyaux, c'est la direction noyaux,

ça tu vois c'est là vie !
l'existence de l'espace , sont incarnation à individualiser le chaos à l'unifier , le connecter à lui même, permettre de tout savoir et tout contrôler à partir d'un seul endroit !!!!!

système d’équilibre, un lieux peut envoyer une demande adressé au noyaux, le noyaux dispose de toute les informations et des moyens de demander des infos à qui y veux, c'est là quelle est traiter

la mémoire est un espace , tentez de formuler une connaissance de l'information depuis sont existence,
le temps virtualiser en espace ,archivage des informations, accumulation de comparateur, développement des réseaux utiliser
ainsi un événement qui c'est passé y a 21 ans mes toujours accessible, c'est étrange,
il y a même des choses d'une époque mystique , avant que le monde n'existe,
être est incroyable , toute ces années dans un réseaux organique terrestre,

j'me suis demander qui sont t'ils ? c'est vrais ça, qui sont tout ces gens, y en à pleins , et ceux de ma famille , d'où y viennes, et moi , qu'est ce que nous somme ?

c'est de la put1 de connexion d'espace !

 :o

put1 j'colle ça fait un moment que j'chuis pas sortie, la 3D a cette effet ,


j'ai fait un alphabet vite fait

ont est en pleines évolution, changer les tableau de la courbe en vect4, je pouvais pas le faire avant d'avoir une interpolation de vect4,
puis y faudra changer la manipulation des point matériel en objet courbe directement associer au tissu pouvais pas le faire avant d'avoir un objet courbe, ont vas se simplifier la vie

function interpol_lagrangeQ4(c,t,M){//c = nombre de points,
 //approprier au interpolation de vect4_
 var y = v4_(0,0,0,0),i=0,q=0,PK=1,
    yy = [[],[],[],[]];
 var len = M.length-1;
 var splin = (1-(c%2)) + (c%2)*.5 -c/2;
 var ti = t-Math.floor(t+splin);//point interpoler
 if(ti%1!=0){
  for(; i<c; i++){
   q = Math.floor(t+i+splin);
   
   if(q<0){q=0}else if(q>len){q=len}
   yy[0][i] = M[ q ].v.x;
   yy[1][i] = M[ q ].v.y;
   yy[2][i] = M[ q ].v.z;
   yy[3][i] = M[ q ].w;
   
   PK *= (ti-i) ;
  }
  for(q=0; q<c; q++){
   i = ((PK/(ti-q))/lagrang[c][q]);
   y.v.x += yy[0][q]*i;
   y.v.y += yy[1][q]*i;
   y.v.z += yy[2][q]*i;
   y.w   += yy[3][q]*i;
  }
 
 }else{
  i = Math.floor(t);
  y.v.x = M[ i ].v.x;
  y.v.y = M[ i ].v.y;
  y.v.z = M[ i ].v.z;
  y.w   = M[ i ].w;
 }
 return y
}
function courbe(){
 //this.cercle = 0;//connection tête à queux
 this.ptr  = [];//  des v4
 this.cptr = [];//courbe croise
 this.len = 0;
}
courbe.prototype = {
 //new: function(){return new },
 //get_v_directeur(t,div); retrun [vecteur_directionnel , ptr],
 add_point: function(ptr,w){
  this.ptr[this.len] = new vect4(ptr,w);
  this.len++;
 },
 get_ptr: function(t){
  return interpol_lagrangeQ4(65,t,this.ptr);
 },
 croiser: function(){//compté egalement le premier et dernier point
  var nl=0;
  this.cptr[nl++] = new vect4(this.ptr[0].v,this.ptr[0].w);
  for(var r=0; r<this.len; r++){
   this.cptr[nl++] = interpol_lagrangeQ4(65, r+1/4 ,this.ptr);
   this.cptr[nl++] = interpol_lagrangeQ4(65, r+3/4 ,this.ptr);
  }
  this.cptr[nl++] = new vect4(this.ptr[this.len-1].v,this.ptr[this.len-1].w);
 },
 get_cptr: function(t){//utilier l'aproximation par crourbe croisé
  var pt = interpol_lagrangeQ4(65,t,this.ptr);//point de la courbe nature

  if(t>.5 && t<this.len-1.5){
    var lp = (1-Math.abs((t%1)*2-1))*2;
        lp = 1-Math.min(1,lp);
        //lp = Math.min(lp*2,1);//avec une marge avant impacte
        lp = 1-(1-Math.sin(( lp-.5)*PI))/2;
    if(lp>0){
     var tc = t*2+.5;
     var cpt = interpol_lagrangeQ4(65,tc,this.cptr);//point de la courbe croiser
     pt.v = cpt.v.bary(pt.v,lp);
     pt.w = cpt.w*lp+pt.w*(1-lp);
    }
  }

  return pt;
 },
 p: function(v){
  for(var r=0; r<this.len; r++){ this.ptr[r].v.p(v) }
 }
}

function courbe_multiple(){
 this.fibre = [];
 this.len = 0;
}
courbe_multiple.prototype = {
 add_fibre : function(c){
  this.fibre[this.len] = c;//new courbe()
  this.len++;
 },
 get_fibre : function(ti){//ti de 0 à 1
  var cou_r = new courbe();
  for(var k=0; k<this.len; k++){
 
   var t = ti*(this.fibre[k].len-1);
   var v = this.fibre[k].get_ptr(t);
   cou_r.add_point(v.v,v.w);
  }
  return cou_r;
 },
 get_cfibre : function(ti){//ti de 0 à 1  , par courbe croiser
  var cou_r = new courbe();
  for(var k=0; k<this.len; k++){
 
   var t = ti*(this.fibre[k].len-1);
   var v = this.fibre[k].get_cptr(t);
   cou_r.add_point(v.v,v.w);
  }
  cou_r.croiser();
  return cou_r;
 },
 p: function(v){
  for(var r=0; r<this.len; r++){this.fibre[r].p(v)}
 },
 croiser: function(v){
  for(var r=0; r<this.len; r++){this.fibre[r].croiser()}
 }
}


dans un tissu ont pourra finalement mètre :
 - une coubre ou courbe_multiple
 - index articulation
 - normal tilt
 - color avec opaciter
 - texture
 - volum_section
 - light*
 - color_spac*
 - disto*

ça avance, le puzzle se complète bien !






pr bossé des textures j'ai trouvé plus simple pas plus rapide, en les métant en 2D ont vois bien mieux les formes et imperfections






j'utilise mon algo de mise à l'échelle en poussant l'itération de l'interpolation à 20²points vus que 10²points c'est parfois pas assez ne me demandez même pas comment ça s'fait que c'est aussi puissant encore j'en suis tout aussi étonné, c'est comme se tapé 2 blru de diamètre20px, t'en mieux hein !
j’apprécie vraiment d'avoir taffé cette algo d'échelle pour les images finalement y sert pour toute sorte de chose, et y marche nickel , la moindre discontinuité se remarquerait sur une texture ! je sais pas ce que les autres utilise mais si il ont pas ce petite algo ça devrait leurs manqué, c'est un petit joyaux

 moyen_carre: function(v,M,iter){
   var t,k = 0,r,vi, a,x,y,x2,y2,x1;
   var li = v_(M.length-1,M[0].length-1);

   for(var i=0; i<iter; i++){//calcule un cercle de point de brouillar
    t  = i/iter*PI2;
    for(var u=1; u<=iter; u++){
     r = u/iter;
     //k += this.carre(  v_( v.x+Math.cos(t)*r , v.y+Math.sin(t)*r )  ,M)*r;
     a = new vect2(cadr(v.x+Math.cos(t)*r,0,li.x),//encadrement
                   cadr(v.y+Math.sin(t)*r,0,li.y));
     x = Math.floor(a.x); x2 = Math.min(x+1,li.x);
     y = Math.floor(a.y); y2 = Math.min(y+1,li.y);
     a.x-=x; a.y-=y;
     x1= 1-a.x;
     k += ((M[x][y] *x1 + M[x2][y] *a.x)*(1-a.y) +
           (M[x][y2]*x1 + M[x2][y2]*a.x)*a.y )*r;
    }
   }
   return k/(iter*(iter+1)/2)
 },
 Echel_normal: function(centre,rayon, B){//vect2 position cerclular normalisateur
   var mi=1000000,ma=-1000000,vr;
   var [X,Y, X1,Y1] = cadr_v(centre.new_p(v_(-rayon.x,-rayon.y)),
                             centre.new_p(rayon),
                             v_(0,0),v_(this.w,this.h) );

   for(var r=X; r<X1; r++){
    for(var u=Y; u<Y1; u++){
     vr = v_((r-centre.x)/rayon.x,(u-centre.y)/rayon.y);
     z =  vr.d(v_(0,0));
     if( z < 1 ){
      z = 1-c(z*z*z*z);
      //z = (1-Math.sin((z-0.5)*PI))/2;
      //z = z*z;
      mi = Math.min(mi,B.M[r][u][0]/z,B.M[r][u][1]/z,B.M[r][u][2]/z);
      ma = Math.max(ma,B.M[r][u][0]*z,B.M[r][u][1]*z,B.M[r][u][2]*z);
     }
   }}
   return [mi,ma-mi]
 },
 Echel_carre: function(divis,iter){  //use this function !
   //mise à l'échelle par interpolation 2point carré avec moyenne
   // iter = 10 est assez bon
   divis = defaul(divis,15);
   iter = defaul(iter,10);

   var x = this.w/divis, y = this.h/divis,
    al_v = v_(x*racineD2,y*racineD2),
       B = this.new(),
      Jm = new Array(divis),//mini
      Jl = new Array(divis);//delta
     
   for(var r=0; r<divis; r++){
    Jm[r] = new Array(divis);
    Jl[r] = new Array(divis);
    for(var u=0; u<divis; u++)
     { [Jm[r][u],Jl[r][u]] = this.Echel_normal(v_(r*x,u*y),al_v,B) }
   }

   var mi,l,v, t,vi;

   for(var r=0; r<this.w; r++){
    for(var u=0; u<this.h; u++){

     v = v_(r/x,u/y);
     mi = interpol.moyen_carre(v,Jm,iter);
     l  = interpol.moyen_carre(v,Jl,iter);
     
     l = l==0 ? 1:l;
     [ this.M[r][u][0],this.M[r][u][1],this.M[r][u][2] ] =
     [ (B.M[r][u][0]-mi)/l ,
       (B.M[r][u][1]-mi)/l ,
       (B.M[r][u][2]-mi)/l ];
   }}

   //this.Echel(v_(0,0),v_(this.w,this.h));//mise à l'échelle absolut
 },

j'ai taffé une approche par point bull aussi , séduisant pour un crépi mais pas applicable sur des polys ,
toujours dans l'optique d'élaboré des chaos monstrueux terrifiant cette fois en 3D
ont vas avoir besoin de fond et de textures pour ce que j'ai prévus dans l'avenir , alors faut pas ce gêné





testé matrice ombrage par tableau associatif,

clé par Normal[x,y,z] sur [0;1[*précision ,cle = x*P² + y*P + z , vecteur normaliser , map_ombre[cle] = distance_min;
calculer la map durant la construction de chaque objet,
pour une spher faire une rotation directionnel vers le point
pour un poly ou un trais généré des point barycentrique
en parallèle pour le poly et densifier sur leurs longueurs normaliser par le point ombre,
prendre la plus courte distance avec une function injection du point,
sur la map z finale calculer l'ombre porté,
utiliser interpolation_sphérique moyenne sur cercle,
 généré un cercle puis appliquer rotation directionnel vers le point_ombrage
 puis normaliser et enfin trouvé les clés affecter,
 devrait déterminer un blur au lieu d'une découpe imprécise et nette,
appliquer l'injection de point seulement pour certain objet

 ::)

l'ombre c'est l'antimatière du light,  une petite ombre ça manque , j'aime les ombres !  ça risque de prendre encore 1/4 de mémoire ,
quant c'est mur y faut cueillir !
j'ai également envie d'affecter en plus de l'opacité un facteur de différence ,
.w =   opacite   ||  [opacite ,  difference ]
je sent que ça vas être utile dans mes recherches,

testé  distorsion d'une surface et redéfinition en multiplicité des points de courbe,
comme ça ont aura besoin de la distorsion pour très peut de point à la fois, ça devrait permettre de façonné des surfaces complexe très rapidement,

::)

ça fait des années que j'attends le bon moment pour coder là Shadow_raster,

function planette_ombre(v,p){
 this.v = v;//point shadow centre planette
 this.p = p;//precision de la spher_map
 this.shadow = new Object();//tablau associatif des distance courte vers .v
}
planette_ombre.prototype = {
 injection: function(ptr){//donner un point d'espace pour l'entrer dans la spher_map
   var dis= this.v.d(ptr);
   var vn = ptr.Nc(this.v);//normal
   var vp = new vect3(
    Math.floor((vn.x+1)/2*(this.p-1)),
    Math.floor((vn.y+1)/2*(this.p-1)),
    Math.floor((vn.z+1)/2*(this.p-1)));
   var cle = vp.x*this.p*this.p + vp.y*this.p + vp.z;

   if( !(cle in this.shadow) ){   this.shadow[cle] = dis }
   else{ if(this.shadow[cle]>dis){this.shadow[cle] = dis } }

 },

premier test


avec beaucoup de précision avec du dessin normaliser avec de l'interpolation ont doit pouvoir avoir une belle ombre !
pour le moment j'ai un objet qui marche , reste à évoluer

bien en une seul journée ont a repousser des limites comme tout les jours enfaite !


function planette_ombre(v,p){
 this.v = v;//point shadow centre planette
 this.p = p;//precision de la spher_map
  this.pm1d2 = (this.p-1)/2;
  this.pc    = this.p*this.p;
 this.shadow = new Object();//tablau associatif des distances courte vers .v
}
planette_ombre.prototype = {
 injection: function(ptr){//donner un point d'espace pour l'entrer dans la spher_map
   var dis= this.v.d(ptr);
   var vn = ptr.Nc(this.v);//normal
   var vp = new vect3(
    Math.floor((vn.x+1)*this.pm1d2),
    Math.floor((vn.y+1)*this.pm1d2),
    Math.floor((vn.z+1)*this.pm1d2));
   var cle = vp.x*this.pc + vp.y*this.p + vp.z;

   //if( !(cle in this.shadow) ){   this.shadow[cle] = dis }
   //else{ if(this.shadow[cle]>dis){this.shadow[cle] = dis } }

   if( !(cle in this.shadow) ){ this.shadow[cle] = [dis,1000000] }
   else{
    if(dis<this.shadow[cle][0]){
     
      if(dis+.05<this.shadow[cle][0] ){ this.shadow[cle][1] = this.shadow[cle][0] }
      this.shadow[cle][0] = dis;
    }
   }

 },
 
 poly: function(f){
   var iter = this.p*PI;
   var a = f.a.Nc(this.v);
   var b = f.b.Nc(this.v);
   var c = f.c.Nc(this.v);
   var dis_ab = a.d(b)*iter;

   for(var r=0; r<=dis_ab; r++){//utiliser les distances normaliser
    var g = r/dis_ab;
    var vab = f.a.bary(f.b,g);

    var ab = vab.Nc(this.v);
    var dis_abc = ab.d(c)*iter;

    for(var u=0; u<=dis_abc; u++){
     var j = u/dis_abc;
     var vabc = vab.bary(f.c,j);

     this.injection(vabc);
    }
   }
 },

 exist_on: function(ptr){
   var dis= this.v.d(ptr);
   var vn = ptr.Nc(this.v);//normal

   var mr = mat3_d0(vn);
   
   var iter = 12;
   var k = 0;
   var c = v3_(0,0,0);
 
   for(var i=0; i<iter; i++){
    var t  = i/iter*PI2;
    for(var u=1; u<=iter; u++){
     var r = u/iter;
     var a = new vect3(Math.cos(t)*r,
                       Math.sin(t)*r,150);//focal de moyenne
     a.r(c,mr);
     a.N();

     var vp = new vect3(
      Math.floor((a.x+1)*this.pm1d2),
      Math.floor((a.y+1)*this.pm1d2),
      Math.floor((a.z+1)*this.pm1d2));
     var cle = vp.x*this.pc + vp.y*this.p + vp.z;
     
     if( cle in this.shadow ){
      //k+=1-fad_sin(this.shadow[cle][0],dis-.1,.1);
      if(this.shadow[cle][1] == 1000000){//premier distance
        k+=fad_sin(dis,
        this.shadow[cle][0]+.1
        ,.1);
      }else{
        k+=fad_sin(dis,
        (this.shadow[cle][0]+this.shadow[cle][1])/2-.1
        ,.1);
      }

     }else{
      k++;
     }

    }
   }
   return k/(iter*iter);
 }

}

// in Vus3D object

 ombrage: function(){
   for(var r=0; r<this.w; r++){
   for(var u=0; u<this.h; u++){
     
     if( this.mz[r][u] != -1000000 ){
      var v = v3_(r-this.wd,this.hd-u,this.mz[r][u]);
      v.scal(1/this.scal);
      var g = (this.perspect+v.z)/this.perspect;
      v.x/=g;  v.y/=g;

      var g = this.ombre.exist_on(v);
      //g = (1+g*3)/4;
      g = (1+g*13)/14;
      this.DD.M[r][u][0] *= g;
      this.DD.M[r][u][1] *= g;
      this.DD.M[r][u][2] *= g;//Math.sqrt(g);

     }
   }}
 },


le truc d'ajouté une moyen focal c'est d’évité les irrégularité de l’espace euclidien et puis c'est tellement plus sexy qu'une shape aliasé, ensuite il faut récupéré les 2 plus courtes distance sans quelles soit confondu , et avec un peut de tacte ont arrive à une ombre potable parfois elle déborde doucement sur des distances proche mais ça vas ,
j'évite le pire cette à dire porté une ombre proche des surfaces exposer , à cause de la confondéson des distances,



puis ça reste puissant , temps de calcule identique d'un scal à un autres , ont peut monter la précision à 1000 pour avoir maximum du~ 1 768 900 de point spher_map, à 200 ça marche mais ont vois des block brluré , ont devrait même pouvoir appliqué plusieurs ombre en même temps , ...

le bonheur quoi !

des vrais ombres en raster une révolution !
wé j'me pet pa ls noix moi ont a qu'une vie et le temps y passe tu sais !

y a des réglage en function de la précision, des paramètres à contrôler,
si j'veux une belle ombre faut sont temps de calcule !
pr l'instant pas très au point,

un fade par distance ombre ou de la planette_shadow , la focal ajusté avec la distance ...
avec une précision de 400 ont reste temporellement et graphiquement convenable , les distance trop éloigner sont fadé comme ça ont élimine les imprécision de l'espace lointain,
c'est pas une ombre parfaite ! et la poussé à l’extrême n'est pas envisageable, pour des travaux pointu utilisant cette méthode vaudra mieux disposer d'une map d'index_objet ont choisira comme ça sur quelle objet permettre des ombres, m'enfin y a encore des découvertes en chemin commençons pas à dramatisé,

pour le moment j'arrive à se rendu imprécis et pas indécent

faut pas s'croire dans un moteur raytrace tout d'même !

y restait encore des conditionnelle à arranger ,

là maintenant l'ombre est nickel, y a juste la marge qui exige beaucoup de précision,

ont devrait même pouvoir faire des rayons crépusculaire !




quelques réglage et ont sera bien





j'ai rien suivi mais les screenshots sont cools

j'adore la font