Auteur Sujet: God Complex  (Lu 15687 fois)

0 Membres et 1 Invité sur ce sujet

Hey!

Je fais un peu de pub rapide pour mon micro framework C++ DX11 qui s'appelle "God Complex": https://github.com/Patapom/GodComplex/wiki

C'était censé être une petit intro au départ, et puis ça a bien dérivé... ;D
Comme d'hab, je suis plus excité par des travaux de longue haleine comme développer une solution de GI qui fonctionne, que de réaliser des p'tits effets de démos, il est donc fort probable que rien ne sortira de tout ça si ce n'est des articles sur mon wiki perso, quand j'aurai le temps. Et p'têt des applications dans certains jeux, qui sait ? ;D

Bisous.

: m_pROOT( NULL )

:D

Sinon joli boulot :)

qu'est ce qu'une "solution de GI" ?

Maracuja : GI = Global Illumination, c'est le Graal du rendu temps réel :D

Je me demande souvent quelle approche est la meilleure en supposant que le hard nous le permette : la rastérisation, ou le raytracing? Autant le raytracing est super attirant pour modéliser des objets mathématiques ou des isosurfaces, autant pour rendre des objets random, c’est une autre paire de manche. En supposant toujours que le hard soit ok, ça implique forcément plusieurs choses : soit de tester tous les triangles à chaque itération (raymarching par exemple) – avec possibilité de kd-tree et ce que vous voulez, soit ça implique une voxélisation du modèle rendu.

Dans tous les cas, est-ce réellement plus élégant et implémentable qu’une bête rastérisation ?

Je pense qu'il faut faire un mix des deux : une voxellisation+raytracing pour calculer l'illumination, et ensuite rasteriser en utilisant les infos collectees. Enfin j'imagine que ca doit etre efficace...

Ouais ça pourrait le faire, mais les infos collectées, ça veut dire quoi ?

Je sais pas, ca doit etre possible de stocker ca dans des buffers ? Il risque surement d'y avoir un probleme de memoire cependant...

Ça s’assimilerait donc à du deferred raytracing :D Non mais je ne vois pas trop l’idée. Par contre, rastériser une première fois la géométrie dans 6 plans avec les 6 depthmap, puis lancer des rayons là dedans, ça me parle plus. En tout cas je suis toujours troublé par cette histoire de raytracing et de rastérisation.

l'idée pour faire du raytracing est de faire une rasterisation de triangles en zbuffer de barycentriques des triangles de la scène 3d avec index du triangle. ensuite la passe de raytracing lit la position relative de l'intersection avec le polygone dans le buffer temporaire ; cela évite tout le test d'intersection et interpoler 3 composantes en rasterisation est très rapide. bref, en tout cas, c'est le seul moyen de faire du raytracing temps réel.
pour faire une seconde passe de réflections, il suffit de faire un rendu dans un cubemap avec le même algo.

j'ai eu cette idée en 2001 ou 2002.

barti c'est à peut près ce que je faisait dans mon raytraceur.
je tronquais les polygones en rectangle puis j'avais une map de 0 ou 1, , puis chaque face était sélectionné par une premier conditionnel  pour savoir si ont est dans le triangle ...
y a une façon de le faire puissant avec des précalcule de map  des conditionnements combinatoire genre nombre de possibilité de 50 faces par point ,  enfin je voulais faire une textmode et prendre mon pied avec de la belle 3D seulement manque de time et de bite pour ,   j'ai toujours utilisé mon moteur raster à chier où ont a pas de caméra

  intersection de face que j'avais tapé y a des 4 ans ou +,  j'aimerais refaire un raytraceur, un moteur simple (polygone/objet classique , lumière ombre, texture...) simple et bien structuré de sorte à être très puissant, intelligent en représentation, et faire un jeu avec, enfin soyons vaine
un chouette jeu d'arcade en 100*160  :D
poin interfac( Dro D , int S )
{
 //recherche du points d'intersection
 //Ix(AAt + BB) + Iy(AA1t + BB1) + Iz(AA2t + BB2) + R = 0
 
 float Tx1,Tx2,Tx3,Ty1,Ty2,Ty3,Tz1,Tz2,Tz3;
 //vec3 v1,v2,Vn;
 //float asx,bsx,csx,dsx;
 
 /*Fase[S].a = noV(Fase[S].a);
 Fase[S].b = noV(Fase[S].b);
 Fase[S].c = noV(Fase[S].c);*/
 
 Tx1 = Fase[S].a.x;//Les 3 points
 Ty1 = Fase[S].a.y;
 Tz1 = Fase[S].a.z;
 
 Tx2 = Fase[S].b.x;
 Ty2 = Fase[S].b.y;
 Tz2 = Fase[S].b.z;
 
 Tx3 = Fase[S].c.x;
 Ty3 = Fase[S].c.y;
 Tz3 = Fase[S].c.z;
 
 
 /*v1.x = Tx2 - Tx1;// les deux vecteurs
 v1.y = Ty2 - Ty1;
 v1.z = Tz2 - Tz1;
 
 v2.x = Tx3 - Tx1;
 v2.y = Ty3 - Ty1;
 v2.z = Tz3 - Tz1;
 
 asx = v1.y*v2.z - v1.z*v2.y;
 bsx = v1.z*v2.x - v1.x*v2.z;
 csx = v1.x*v2.y - v1.y*v2.x;
 dsx = -v1.y*v2.z*Tx1 -v1.z*v2.x*Ty1 -v1.x*v2.y*Tz1 +v1.y*v2.x*Tz1 +v1.z*v2.y*Tx1 +v1.x*v2.z*Ty1;
 
 Vn = asign( asx , bsx , csx );//normale
 Fase[S].n = Normalize(Vn);*/
 
 
 poin te;
 float IX,IY,IZ,RS,ti,de;
 float DIV,a,b,c,dw,ew,fw,gw,hw,iw,jw,kw,lw,xw,yw,zw;
 
 IX = Fase[S].n.x;//asx;
 IY = Fase[S].n.y;//bsx;
 IZ = Fase[S].n.z;//csx;
 RS = Fase[S].w;//dsx;
 
 de = IX*D.a + IY*D.c + IZ*D.e;
 
 if( de < 0 | de > 0 ){
 
  ti = ( - IX*D.b - IY*D.d - IZ*D.f - RS )/de;
 
  te.d = ti;
 
  if( ti >= 0 ){
   
   dw = Tx1;
   ew = Tx2;
   fw = Tx3;
   
   gw = Ty1;
   hw = Ty2;
   iw = Ty3;
   
   jw = Tz1;
   kw = Tz2;
   lw = Tz3;
   
   xw = D.a*ti+D.b;
   yw = D.c*ti+D.d;
   zw = D.e*ti+D.f;
   
   //solve( { ( a*d + b*e + c*f )/100 = x , ( a*g + b*h + c*i )/100 = y , ( a*j + b*k + c*l )/100 = z },{a,b,c} )
   DIV = dw*(iw*kw - hw*lw) + ew*(gw*lw - iw*jw) + fw*(hw*jw - gw*kw);
   a = 100*(zw*(fw*hw - ew*iw) + yw*(ew*lw - fw*kw) + xw*(iw*kw - hw*lw));
   a /= DIV;
   b = 100*(zw*(dw*iw - fw*gw) + yw*(fw*jw - dw*lw) + xw*(gw*lw - iw*jw));
   b /= DIV;
   c = 100*(zw*(ew*gw - dw*hw) + yw*(dw*kw - ew*jw) + xw*(hw*jw - gw*kw));
   c /= DIV;
   
   if ( a <= 100 && a >= 0 && b <= 100 && b >= 0 && c <= 100 && c >= 0 )
   { te.exist = 1; }else{ te.exist = 0; }
   
  }else{ te.exist = 0; }
  te.n = S;
  te.t = 1;//1 for a Face
 
 }
 else{
 
  te.exist = 0;
 
 }
 
 return te;
}


Je me demande souvent quelle approche est la meilleure en supposant que le hard nous le permette : la rastérisation, ou le raytracing? Autant le raytracing est super attirant pour modéliser des objets mathématiques ou des isosurfaces, autant pour rendre des objets random, c’est une autre paire de manche. En supposant toujours que le hard soit ok, ça implique forcément plusieurs choses : soit de tester tous les triangles à chaque itération (raymarching par exemple) – avec possibilité de kd-tree et ce que vous voulez, soit ça implique une voxélisation du modèle rendu.

Dans tous les cas, est-ce réellement plus élégant et implémentable qu’une bête rastérisation ?

Honnêtement, j'pense que dans 10 ans on a ça sur toutes les bécanes grand public et qu'il faut oublier les triangles : http://raytracey.blogspot.fr/2013/10/brigade-3.html


Ouais 'fin Carmack il est un peu resté dans les années 90, il a jamais écrit un compute shader de sa vie le type. Vu qu'on s'oriente vers du massivement parallèle tous azimuts, je peux garantir que ces "milliards de rayons" on va les atteindre très très vite !
Et puis l'importance sampling c'est pas pour les chiens : si tu samples pas ta BRDF comme un pied t'es pas obligé d'envoyer des "milliards de rayons"... ;D

Je trouve quand même plus intelligentes les solutions qui rasterisent les premiers rayons et raytracent les rayons secondaires. Smash fait ça actuellement en voxélisant la scène à chaque frame pour avoir une représentation basse résolution de la scène mais facile à raytracer. Ca permet pas de faire ce que fait brigade mais ça permet d'avoir un résultat noise-free en temps réel.