Auteur Sujet: HS pixelartdisk  (Lu 38047 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

merci wu,  j'en avais mare de faire des tubes abstrait , ça pouvait s’appliquer à des lettrages , ça sera utile


j’entame les surface démultiplier,  texturisation matériel ,
j'ai découvre qu'ont peut de cette façon reprendre la normal d'une texture du cou avoir des volume globuleux plutôt que simple reliefs ,
loin dans avoir fait le tour,  résoudre la discontinuité de l'interpolation était totalement nécessaire à ce type d'objet !


 surfac: function(iterat,segment,textured){//return courbe multiple
   //textured = new texture_object();
   //redefinition de la surface suivent une texture
   //segment = nombre de tranche
   //iterat = nombre de courbe, 1 = .len existant
   
   if(typeof textured == "object"){
     var np = this.len-1;
     var iter_div = np/iterat;
     this.croiser();

     var cou_m = new courbe_multiple();

     for(var r=0; r<segment; r++){
      var i1 = r/segment;
      var i2 = (r+.01)/segment;
      var cou_aret1= this.get_cfibre(i1);
      var cou_aret2= this.get_cfibre(i2);

      var Mp = new courbe();
      for(var k=0; k<iterat; k++){
       var t1= k*iter_div;
       var t2= (k+.01)*iter_div;
   
       var o_cv1 = cou_aret1.get_cptr(t1);//util pour avoir le point de force .w
       var cv1 = o_cv1.v;
       var cv2 = (cou_aret1.get_cptr(t2)).v;
       var dv1 = (cou_aret2.get_cptr(t1)).v;
   
       var n_cv1 = new vect3(dv1.x-cv1.x, dv1.y-cv1.y, dv1.z-cv1.z);
       n_cv1 = n_cv1.VN( new vect3(cv2.x-cv1.x, cv2.y-cv1.y, cv2.z-cv1.z) );
   
       var o1 = textured.texture(new vect2(t1/np,i1));
   
       n_cv1.scal( o1*o_cv1.w );
   
       cv1.p(n_cv1);

       Mp.add_point(cv1,//rf(1));//sans transmition de force volumique
                        o_cv1.w);
      }
      cou_m.add_fibre(Mp);
     }
     
     //inversion de la table
     var cou_transpose = new courbe_multiple();
     for(var k=0; k<iterat; k++){
      var Mp = new courbe();
      for(var r=0; r<segment; r++){
       Mp.add_point(cou_m.fibre[r].ptr[k].v,cou_m.fibre[r].ptr[k].w);
      }
      cou_transpose.add_fibre(Mp);
     }

     return cou_transpose;
   }

 }

sans usage d'une courbe croisé pour anéantir les discontinuités, ont aurait ça, :


ont avance étape par étape, maitrisé un procédé permet de réaliser d'autre procédé ~impossible à envisager avant,

je taff agréablement les texture avec un objet texture ,
function texture_object(){
 this.tx = function(){return 1};//function de la texture
 this.px = function(v){return v}; //position dans la texture
 this.rx = 1;//relief
 this.texture = function(v){ return Math.max(0,this.tx(this.px(v))*this.rx) };
 this.doubl_surfac = 0;//surface en relief symétrique
}


var tex = new texture_object();
 tex.doubl_surfac = 0;
 tex.rx = 1;
 tex.px = function(v){return new vect2(v.x*10*2,v.y*3*2)};//Math.asin(Math.sin(t1));
 tex.tx = //function(v){return (Math.sin(v.x)+1)*(Math.cos(v.y)+1)/4 };
          //grillage;
          section_chaos_oeil;

 //...

 var cou_demultiplie = cou_m.surfac(5*40,5*40,tex);//redéfinition de la surface
 
 cou_demultiplie = cou_demultiplie.surfac(5*100,5*100,tex2);

 PRINT("texty" , "temps texturisation materiel = " + HEUR(TIME()-tim) +"<br>" ,1);

 C.surfac(cou_demultiplie,iertation,color,1 ,tex2);//dessin 3D de la surface


démultiplier des courbes multiple ça permet de s'épargner le calcule de tout les points d'une texture,

là j'pense à évoluer mon algo de surface, pour ne plus avoir besoin de démultiplication ,  ont calculera toute les textures d'un cou dans une matrice de normal , ça vas être un casse tête mais le rendu sera plus précis et contrairement à la démultiplication ça prend pas de mémoire ,
c'est ça l'algo qui m'faut, et ça peut s’optimisé, par contre casse tête à codé !
ont pourra enchainer 3 textures directement , même 20 textures si ont veux, il me faut cette algo !
c'est 1/4 de matrice pyramidal , ça tombe bien les point déjà calculer seront préservé,   y a moyen,

vais essayé de faire des goutes qui se tienne debout

je sent que ça défit un peut mon intellect , devrait utiliser une matrice_en_environnement avec colonne_index de remplacement,
fonction de normalisation devra être bien foutu,
évidement la symétrie volumique ne dépendra plus de la texture , et les reliefs serait préférable en instruction tableau ;


il est trop tôt pour expérimenter le tissu interconnecter

Surface interconnecter,  réaliser des connexion entre courbe par point de courbe, puis associer des carreaux de 4 côté avec les points de courbe,
les connections serve à définir des courbes en vrac,
devrait permettre de modéliser toute sorte de surface avec des trous et des bras ...
un carreau peut être démultiplier,
l'approche interpolation des points de croisement est pour le moment incertaine,
point de croisement de 3 à 7 branches;

comment obtenir des points d'un objet complexe ?
comment trouvé des carreaux interconnecter correctement à partir de ces points ?
comment avoir une dispersion homogène des points ?

faire des points et trouvé les carreaux, puis trouvé les courbes ;
les courbes devrons géré l'interpolation en boucle continu ,
je ne sais pas non plus comment définir une texturisation de ce type de surface, texture spatial ,   c'est peut être non-envisageable par contre reprendre des points avec normal devrait permettre pleins de chose, aussi attacher des courbes_multiple ensuite ...

à médité prochainement ,
pour le moment j'ai un algo de multi_texturisation_volumique à faire qui m'intéresse beaucoup

y a vraiment du taf,

l'algo s'optimise assez simplement justement, suffit de recalculer les valeurs inconnu et de faire du déplacement d'information,

multi texturisation volumique,  j’enchaine 3-4 textures temporellement convenable,
 surfac0: function(cou_m,iterat,fcolo,opac ,textured){
   //textured = tableau de  new texture_object();
   var np = cou_m.len-1;
   var iter_div = np/iterat;
   cou_m.croiser();
   

   var mc = textured.length;//nombre de textures
   var mc2 = mc+2,
       mc1 = mc+1;

   var i = new Array(mc2);
   var cou_fibre = new Array(mc2);
   for(var k=0; k<mc1; k++){
    i[k] = k/iterat;
    cou_fibre[k] = cou_m.get_cfibre(i[k]);
   }
   //utiliser 3 normal donc 3 courbe !!!
   for(var r=0; r<iterat; r++){
   
    i[mc1] = (r+mc1)/iterat;
    cou_fibre[mc1] = cou_m.get_cfibre(i[mc1]);
    //faire tourner les fibres
   
   
    var t = new Array(mc2);
    for(var j=0; j<mc2; j++){
     t[j] = (k+j-1)*iter_div;
    }
    var mn = new Array(mc2);//matrice de normal
    for(var j=0; j<mc2; j++){
     mn[j]=[];
     for(var u=0; u<mc2; u++){
      mn[j][u]=[];
      mn[j][u][0]=cou_fibre[j].get_cptr(t[u]);
      mn[j][u][mc1]=1000000000;
      for(var l=1; l<mc1; l++){
       mn[j][u][l]=-1;
      }
     }
    }

    for(var k=0; k<iterat; k++){


     //faire tourner la matrice mn

     for(var j=0; j<mc1; j++){ t[j] = t[j+1] }
     t[mc1] = (k+mc1)*iter_div;

     for(var j=0; j<mc2; j++){
      for(var u=0; u<mc1; u++){
       mn[j][u][0]=mn[j][u+1][0];
       mn[j][u][mc1]=mn[j][u+1][mc1];
       for(var l=0; l<mc2; l++){
        mn[j][u][l]=mn[j][u+1][l];
       }
      }

      for(var u=1; u<mc1; u++){
       mn[j][mc1][u]=-1;
      }
      mn[j][mc1][0]=cou_fibre[j].get_cptr(t[mc1]);
      mn[j][mc1][mc1]=1000000000;
     }
     
     

     for(var q=0; q<mc; q++){
      var mt = mc1-q;
      for(var j=0; j<mt; j++){
       for(var u=0; u<mt; u++){
       
        if(mn[j][u][q+1] ==-1 ){
          var c1,c2,d1;
          if(q==0){
            c1 = mn[j][u][0].v;
            c2 = mn[j][u+1][0].v;
            d1 = mn[j+1][u][0].v;
          }else{
            c1 = mn[j][u][q];
            c2 = mn[j][u+1][q];
            d1 = mn[j+1][u][q];
          }
 
          var n_c = new vect3(d1.x-c1.x, d1.y-c1.y, d1.z-c1.z);
          n_c = n_c.VN( new vect3(c2.x-c1.x, c2.y-c1.y, c2.z-c1.z) );
          var o1 = textured[q].texture(new vect2(t[u]/np,i[j]));
          mn[j][u][mc1]=Math.min(o1,mn[j][u][mc1]);// suivi de si o == 0
          n_c.scal( o1*mn[j][u][0].w );
          n_c.p(c1);
          mn[j][u][q+1]=n_c;
        }

       }
      }
     }

   
     var cv1 = mn[0][0][mc];//mc
     var cv2 = mn[0][1][mc];
     var dv1 = mn[1][0][mc];
     var dv2 = mn[1][1][mc];
     
     var cle = 0;
     if(mn[0][0][mc1]>0){cle+=1}
     if(mn[0][1][mc1]>0){cle+=10}
     if(mn[1][0][mc1]>0){cle+=100}
     if(mn[1][1][mc1]>0){cle+=1000}
     
     switch(cle){
     case 1111://o1>0 && o2>0 && o3>0 && o4>0){
      this.Polygon(new Fac(cv1,cv2,dv1),fcolo,0,0, opac);
      this.Polygon(new Fac(dv2,dv1,cv2),fcolo,0,0, opac);
     break;case 111://o1>0 && o2>0 && o3>0 && o4==0){
      this.Polygon(new Fac(cv1,cv2,dv1),fcolo,0,0, opac);
     break;case 1110://o4>0 && o2>0 && o3>0 && o1==0){
      this.Polygon(new Fac(dv1,cv2,dv2),fcolo,0,0, opac);
     break;case 1011://o1>0 && o2>0 && o4>0 && o3==0){
      this.Polygon(new Fac(cv1,cv2,dv2),fcolo,0,0, opac);
     break;case 1101://o1>0 && o3>0 && o4>0 && o2==0){
      this.Polygon(new Fac(cv1,dv2,dv1),fcolo,0,0, opac);
     break;}
     
    }
   



    for(var k=1; k<mc2; k++){
     i[k-1] = i[k];
     cou_fibre[k-1] = cou_fibre[k];
    }


   }
 }

high résolution



j'ai bien profité de 10jrs de tranquillité par l'absence du voisin, j'ai peu me concentré et coder un peut de l'évolution,

comment densifier les zones d’expansion ?

bien ce genre d'algo pourra s’appliqué au tube également,
faut rajouté l'application de l'ombrage dans la compilation de la matrice d'opacité,  taffé sur l'option multi points opacité pour la planette_shadow ça prendre beaucoup de mémoire mais utiliser en juste mesure ça peut être cool,
ajouté facteur différence très tardivement,
faire le ménage ds function d'ancienne version de manipulation texture...
dissoudre la manipulation de point matériel dans objet body ...
complété squelette ...
...

cette prolongation intensive dans une réalité procédural au représentant immatériel a causé une observation objective des figurations matériel monstrueusement accumuler de notre monde ,
il s'agissait du nom humain définition assimilative et perceptive, l'ombre n'était plus une empreinte elle semblait n'être que l'espace d'inexistence de l'exposition, sentiment d'illusion,
le rocher(the rock) n'était plus une reconnaissance de l'objet physique et granuleux tombé à terre, il était une texture extrêmement sophistiqué, ces constituants était algorithmique, tout chose était une 3D incroyable au rendu terrifiant , cette quantité d’implication métabolique était obscène pour tout analyse possible de ma par


C'est très cool les textes du 16 février

j'réfléchi à comment généré un mesh finalement, ont vas être beaucoup obliger de stoké des polygones avec des points,  pour le moment c'est pas au programme je peut m'en passé et continuer à tout faire avec des surfaces en courbe, ça vas très bien, c'est juste que dans l'avenir j'aurais forcément envie d'aller plus loin , selon moi la prochaine étape c'est d'interpoler un objet complexe , pas des quads mais bien des polys, et après ça ont pourra densifier des zone d’expansion, faudra trouvé un remède contre le manque de mémoire vive, à moins que je trouve une façon paramétrique ça serait super,
la texturisation j'vois différente façon BADante , rotation directionnel d'un espace texture par une normal d'un point, des trucs comme ça, mais sinon le mieux serait de mappé l'objet avec des surfaces    très moyen~ , ont devrait pouvoir localiser des textures et appliqué une micro texture globale



faire des point trouvé les triangles trouvé les courbes arrêtes , interpoler étape par étape ou mieux ...

mais c'est pas pour bientôt , faut que l'idée murisse, ça ferait même pas du vin là


pr le moment j'continu de perfectionné et d'exploré ,
apparemment j'ai trouver une inflexion du temps de calcule entre les 2 méthodes, utiliser des surfaces démultiplier demande plus de temps de calcule que mon algo, ça aurait été l'inverse si ma texture était plusse gourmande, j'doigte 3 textures en même temps ça me prend 1h30  avant ça prenait 4h ~proportionnellement , ça viens pas du spline de l'interpolation plusse de la taille du tableau à gratté,  définir des fibres prend tout les points colonne ce qui amène une augmentation de type exponentiel(²...) du nombre de point à interpoler  ,

avant de voyager dans les particules et surface complexe faudrait avancer sérieusement le body , j'ai de quoi façonné des ossement avec texture volumique ,

créé là vie !
si dieu le peu , il le fera !