Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2018-01-24T01:49:25+01:00Les derniers messages parus sur le forum de Zeste de Savoir.Moteur physique et correction de la position, message #1724242018-01-24T01:49:25+01:00Epoxyc/@Epoxychttps://zestedesavoir.com/forums/sujet/10175/moteur-physique-et-correction-de-la-position/?page=1#p172424<p>Salut,
Merci pour ta réponse!
J’avais pensé à ce genre de solutions : pour ta première idée, j’avais implémenté une dichotomie dans le temps pour trouver l’instant exact du premier impact, c’est un bonne solution si on veut éviter totalement les interpénétrations, mais c’est quand même beaucoup plus lent. Mais dans mon cas, le problème survient quand les objets sont déjà en collision c’est à dire que le temps d’impact est t+0 et les objets ne s’éloigneront plus. Il faudrait donc calculer une réponse une infinité de fois entre deux itérations, impossible.
J’avais aussi pensé à la deuxième, garder un graphe des contacts (ce que je suis en train d’implémenter pour des raisons d’optimisation). Mais justement, des objets en contact peuvent glisser ou rouler les uns sur les autres, le but étant juste de les empêcher de s’interpénétrer.</p>
<p>Nous avions commencé ce projet il y a deux ans et nous l’avions abandonné par manque de temps et notamment à cause de ce problème. Cependant, la réponse impulsionnelle est beaucoup trop complexe pour la déboguer facilement et ce n’est pas moi qui ai écrit toutes les fonctions de génération de contact (qui sont peut être boguées aussi).</p>
<p>Je suis en train de lire quelques papiers qui soulignent ce problème, je trouve la doc de Box2D assez intéressante et facilement généralisable à la 3D. Le moteur autorise une petite interpénétration et introduit un biais de vitesse proportionnel à la distance d’interpénétration (et inversement proportionnel au pas de simulation ???). J’étais en train d’essayer d’ajouter une réponse en position proportionnelle à la distance d’interpénétration pondérée pour chaque objet par rapport à sa masse et son moment d’inertie.</p>
<p>Je vais essayer de simplifier un peu pour le moment, enlever la friction et avoir un système fonctionnel avec des boites (dont j’ai écrit et testé les algos de contact) car il semble y avoir quelques problèmes pour le moment avec les réponses impulsionnelles impliquant de la friction et que le code écrit en C++ n’est pas trop optimisé (trop de polymorphisme :p). Puis essayer quelques autres solutions comme celle de Box2D.</p>
<p>Si vous avez d’autres idées (même farfelues) ou des papiers à me conseiller, n’hésitez pas <img alt=":)" src="/static/smileys/smile.png"> </p>Moteur physique et correction de la position, message #1724072018-01-23T21:27:12+01:00tleb/@tlebhttps://zestedesavoir.com/forums/sujet/10175/moteur-physique-et-correction-de-la-position/?page=1#p172407<p>Salut,</p>
<p>Au lieu de t’y prendre après l’impact, tu ne peux pas t’y prendre avant (vérifier qu’un impact ne va pas arriver entre l’itération actuelle et la prochaine) ? Ça rajoute du calcul et il ne faut pas négliger si l’objet qui va être touché doit encore bouger ou non, mais ça resoudrait ton problème. Par contre, aucune idée si c’est envisageable comme solution.</p>
<p>Ou sinon, si il s’est passé un contact entre l’itération actuelle et celle précédente, tu reviens à la précédente en anticipant cette fois-ci (il peut arriver que tu aies à revenir plusieurs fois, si cette modification crée un autre impact).</p>
<p>J’ai balancé des idées à la mer, ça m’étonnerait que ça soit utilisable, mais bref.</p>Moteur physique et correction de la position, message #1723742018-01-23T12:06:57+01:00Epoxyc/@Epoxychttps://zestedesavoir.com/forums/sujet/10175/moteur-physique-et-correction-de-la-position/?page=1#p172374<p>Bonjour !
Je développe un petit moteur de jeu avec des amis et je me m’occupe de toute la partie physique.
J’ai déjà implémenté tout ce qui était découpage de l’espace et détection des collisions pour les primitives de base (point + normale + distance d’interpénétration).</p>
<p>Concernant la réponse aux collisions, j’ai choisi une réponse impulsionnelle. J’utilise donc une méthode itérative (Gauss-Seidel) pour approcher la solution et cela fonctionne plutôt bien pour la réponse en vitesse, même si il y a beaucoup de solides en contact.</p>
<p>Cependant je suis confronté à quelques petits problèmes pour la réponse en position. Lorsque le coefficient de restitution est strictement inférieur à 1 (plus de conservation de l’énergie durant le choc), la réponse en vitesse n’éloigne pas autant les objets après intégration que ce qu’ils s’étaient rapprochés le temps du pas de simulation.</p>
<p>Je m’explique, si j’ai deux objets avec une vitesse relative nulle, mais qui accélèrent l’un vers l’autre, exemple : le sol et un objet posé dessus, alors durant la simulation, l’accélération va être intégrée en vitesse et comme il n’y a pas conservation de l’énergie, la réponse en vitesse ne va pas annuler totalement celle-ci et, à la prochaine itération l’objet va un peu plus interpénétrer le sol. On voit donc l’objet passer très lentement à travers le sol.</p>
<p>La solution est donc de repositionner l’objet au point de collision juste avant de calculer la réponse en vitesse (réponse en position) en "remontant" dans le temps. J’ai donc posé les équations de mouvement et les ai inversées (elles sont horribles mais correctes), cependant, si ça fonctionne pour un objet, pour un problème à n objets, cela finit par diverger. En effet, la réponse en position créé de nouvelles collisions (en séparant d’autres objets), qui ne seront détectés qu’à l’itération d’après, le solveur va essayer de retrouver le point de collision avec les équations du mouvement, mais dans ce cas les objets n’étaient peut être pas en train de se rapprocher, le solveur ne peut donc trouver de solution valide avec uniquement ces équations et finit par diverger.</p>
<p>J’ai donc essayé quelques chose de plus simple, de séparer les objets uniquement selon la normale de contact et leur masse/opérateur d’inertie, mais ce modèle n’est pas cohérent et cause quelques inexactitudes visibles notamment lorsque les vitesses de rotations sont élevées et cela devient pire lorsqu’on ajoute les frottements.</p>
<p>Exemple : un objet en équilibre sur un sol en pente et un autre l’empêche de rouler/glisser. Durant l’itération, l’accélération gravitationnelle va donner une vitesse à l’objet, qui va être intégrée en déplacement, le solveur va détecter la collision, répondre en impulsion (quasi inversement de la vitesse normale et donner une vitesse de rotation à cause des frottements), le solveur de position replace l’objet au point de contact, mais la réponse en vitesse n’est pas nulle, après intégration, l’objet s’éloigne un petit peu du sol, cela fait apparaître un phénomène de léger "tremblement" et des réactions bizarres dues aux frottements. </p>
<p>Je me demandais donc si des solutions étaient connues à ce problème ou alors si je devrais considérer le fait de détecter lorsque des objets sont en contact durant plusieurs itérations et appliquer un autre modèle pour résoudre ces collisions.</p>
<p>Merci d’avance. </p>Simulation de la position du Soleil, message #1448732017-03-18T20:19:42+01:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144873<p>Pour A312_2 j’ai un peu tricher en utilisant cette méthode (j’ai utilisé un raccourci valable dans un monde 2D). Il faudra peut-être se baser sur le commentaire de mon premier message.</p>
<p>Dans un espace 3D j’ai peur que ça fasse : <code>( o (</code> au lieu de <code>( o )</code>. C’est-a-dire qu’il faut tourner l’arc de cercle. Dans l’idée je pense qu’il faut ajouter un système de vecteur et remplacer mon <code>-Math.Pi</code> dans la fonction cos/sin (que j’ai mis pour avoir <code>( o</code> et non <code>) o</code>).</p>
<p>Pour joindre A312 et A312_2, il me semble, qu’il faut prendre en compte la valeur relative/constante une seule fois, c’est-à-dire enlever (230 ou 70) de la deuxième fonction et l’ajouter à la suite du premier calcul.</p>Simulation de la position du Soleil, message #1448702017-03-18T19:30:02+01:00Seb/@Sebhttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144870<p>Merci beaucoup, cela m’a beaucoup aidé dans la compréhension du phénomène. J’ai transformé le code de ta fonction a312() pour qu’il fonctionne dans un espace en 3 dimensions avec mon code:</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c1">//FONCTIONS D'APRES LE PROJET GITHUB...</span>
<span class="c1">// On ajoute le projecteur de lumière</span>
<span class="kd">var</span> <span class="nx">dirLight</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">THREE</span><span class="p">.</span><span class="nx">DirectionalLight</span><span class="p">(</span><span class="mh">0xffffff</span><span class="p">,</span> <span class="mi">1</span><span class="p">);</span>
<span class="nx">scene</span><span class="p">.</span><span class="nx">add</span><span class="p">(</span><span class="nx">dirLight</span><span class="p">);</span>
<span class="kd">var</span> <span class="nx">min</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="kd">function</span> <span class="nx">day_night</span><span class="p">(</span><span class="nx">time</span><span class="p">)</span> <span class="p">{</span>
<span class="kr">const</span> <span class="nx">coord</span> <span class="o">=</span> <span class="nx">sunCoordinates</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">utcOffset</span><span class="p">(</span><span class="mi">0</span><span class="p">).</span><span class="nx">format</span><span class="p">(</span><span class="s1">'x'</span><span class="p">));</span>
<span class="kr">const</span> <span class="nx">earthRadius</span> <span class="o">=</span> <span class="mi">200</span><span class="p">;</span>
<span class="kr">const</span> <span class="nx">r</span> <span class="o">=</span> <span class="mi">1500</span><span class="p">;</span>
<span class="kr">const</span> <span class="nx">h</span> <span class="o">=</span> <span class="nx">coord</span><span class="p">.</span><span class="nx">hourAngle</span><span class="p">;</span>
<span class="kr">const</span> <span class="nx">d</span> <span class="o">=</span> <span class="nx">coord</span><span class="p">.</span><span class="nx">declination</span><span class="p">;</span>
<span class="kd">let</span> <span class="nx">x</span> <span class="o">=</span> <span class="nx">earthRadius</span> <span class="o">+</span> <span class="nx">r</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">cos</span><span class="p">(</span><span class="nx">h</span><span class="p">)</span>
<span class="kd">let</span> <span class="nx">y</span> <span class="o">=</span> <span class="mi">0</span>
<span class="kd">let</span> <span class="nx">z</span> <span class="o">=</span> <span class="nx">earthRadius</span> <span class="o">+</span> <span class="nx">r</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">sin</span><span class="p">(</span><span class="nx">h</span><span class="p">)</span>
<span class="nx">dirLight</span><span class="p">.</span><span class="nx">position</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">,</span> <span class="nx">z</span><span class="p">);</span>
<span class="nx">dirLight</span><span class="p">.</span><span class="nx">updateMatrix</span><span class="p">();</span>
<span class="p">}</span>
<span class="nx">setInterval</span><span class="p">(</span><span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
<span class="nx">min</span><span class="o">++</span><span class="p">;</span>
<span class="kd">let</span> <span class="nx">date</span> <span class="o">=</span> <span class="nx">moment</span><span class="p">(</span><span class="k">new</span> <span class="nb">Date</span><span class="p">()).</span><span class="nx">add</span><span class="p">(</span><span class="nx">min</span><span class="p">,</span> <span class="s1">'minutes'</span><span class="p">);</span>
<span class="nx">day_night</span><span class="p">(</span><span class="nx">date</span><span class="p">);</span>
<span class="p">},</span> <span class="mi">100</span><span class="p">);</span>
</pre></div>
</td></tr></table></div>
<p>On peut ainsi remarquer que l’axe y devient en 3D l’axe z (je t’apprend rien). Le résultat est bien celui espéré.
Cependant j’ai un petit problème avec la deuxième fonction a312_2(), on remarque que c’est l’axe x et l’axe y qui varient, ainsi je suppose qu’il faille faire une sorte de mixe des 2 fonctions en ce qui concerne l’axe x et qu’il faille appliquer l’axe y de ta deuxième fonction à l’axe y, soit: <code>let y = earthRadius + r * Math.sin(d-Math.PI)</code>…</p>Simulation de la position du Soleil, message #1448562017-03-18T17:51:17+01:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144856<p>Je j’ai fais une démo (en 2D) : <a href="http://jsbin.com/tebukugava/1">http://jsbin.com/tebukugava/1</a></p>
<p>Le plus compliqué sera le calibrage. Je pense que l’origine 0 passe par le Méridien de Greenwich.</p>Simulation de la position du Soleil, message #1448422017-03-18T17:00:52+01:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144842<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7
8
9</pre></div></td><td class="code"><div class="codehilite"><pre><span></span> <span class="nx">getSunVector</span><span class="p">()</span> <span class="p">{</span>
<span class="kd">let</span> <span class="nx">moment</span> <span class="o">=</span> <span class="k">this</span><span class="p">.</span><span class="nx">calculatedMoment</span><span class="p">()</span>
<span class="kd">let</span> <span class="nb">sun</span> <span class="o">=</span> <span class="nx">sunCoordinates</span><span class="p">(</span><span class="nx">_</span><span class="p">.</span><span class="nx">toInteger</span><span class="p">(</span><span class="nx">moment</span><span class="p">.</span><span class="nx">format</span><span class="p">(</span><span class="s1">'x'</span><span class="p">)))</span>
<span class="kd">let</span> <span class="nx">light</span> <span class="o">=</span> <span class="nx">m4</span><span class="p">.</span><span class="nx">identity</span><span class="p">()</span>
<span class="nx">light</span> <span class="o">=</span> <span class="nx">m4</span><span class="p">.</span><span class="nx">rotateY</span><span class="p">(</span><span class="nx">light</span><span class="p">,</span> <span class="p">(</span><span class="nb">Math</span><span class="p">.</span><span class="nx">PI</span> <span class="o">/</span> <span class="mi">2</span><span class="p">)</span> <span class="o">-</span> <span class="nb">sun</span><span class="p">.</span><span class="nx">hourAngle</span><span class="p">)</span>
<span class="nx">light</span> <span class="o">=</span> <span class="nx">m4</span><span class="p">.</span><span class="nx">rotateZ</span><span class="p">(</span><span class="nx">light</span><span class="p">,</span> <span class="o">-</span><span class="nb">sun</span><span class="p">.</span><span class="nx">declination</span><span class="p">)</span>
<span class="k">return</span> <span class="nx">light</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
<p>D’après ce que <a href="https://github.com/k9/globe-viewer/blob/8dd972feab06866e7fbe0bdd063e5e73c6de28f5/app/js/renderer.js#L62-L76">j’ai compris du code <em>renderer.js#L62-L76</em></a> ils appliquent l’effet jour/nuit avec un shader et non un objet <em>DirectionalLight</em>.</p>
<figure><img alt="" src="http://i.imgur.com/M5JAwSz.png"><figcaption>Vue de face</figcaption>
</figure>
<p>La déclinaison permet de définir la hauteur du soleil via l’angle T. Avec un peu de <a href="http://www.automaths.com/3/cours/3_Trigonometrie_C.pdf">trigonométrie</a> et <a href="https://fr.wikipedia.org/wiki/Th%C3%A9or%C3%A8me_de_Pythagore">le théorème de pythagore</a> tu peux obtenir la position (hauteur) du point S en partant de T.</p>
<hr>
<p>Pour <em>hourAngle</em> c’est le nombre de résolution depuis le 1er janvier 2000 en fonction de π (PI). Où une résolution est égale à 2π (soit 6.28).</p>
<figure><img alt="" src="http://i.imgur.com/9mDiOkx.png"><figcaption>vue de haut</figcaption>
</figure>
<p>Une fonction <a href="http://stackoverflow.com/questions/839899/how-do-i-calculate-a-point-on-a-circle-s-circumference">comme ça</a> devrait suffire il me semble. Pour dessiner un point sur le périmètre d’un cercle en fonction d’un angle.</p>Simulation de la position du Soleil, message #1448272017-03-18T15:33:36+01:00Gawaboumga/@Gawaboumgahttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144827<p>Avec ThreeJS, on peut <a href="https://threejs.org/docs/index.html#Reference/Objects/Group">regrouper</a> des objets comme un seul être.</p>Simulation de la position du Soleil, message #1447952017-03-18T11:58:35+01:00Seb/@Sebhttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144795<p>En effet, c’est une autre façon de procéder <img alt=":)" src="/static/smileys/smile.png"> . Le problème est que mon globe est composé de plusieurs meshes. Il faut donc que j’effectue une rotation pour chacun, c’est pas très pratique, notamment en ce qui concerne le mesh s’occupant du cycle nuit où j’effectue justement des rotations…</p>Simulation de la position du Soleil, message #1447912017-03-18T11:25:00+01:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144791<p>Tu as essayé de tourner la terre et ta caméra, au lieu de tourner le soleil ? <img alt=";)" src="/static/smileys/clin.png"> </p>Simulation de la position du Soleil, message #1447672017-03-17T23:44:44+01:00Seb/@Sebhttps://zestedesavoir.com/forums/sujet/8227/simulation-de-la-position-du-soleil/?page=1#p144767<p>Salut <img alt=":)" src="/static/smileys/smile.png"> ,</p>
<p>Je voudrais avec Three.js reproduire le résultat dispo sur <a href="http://www.satflare.com/track.asp?q=25544">ce site</a> c’est à dire <strong>reproduire la position du soleil sur une sphere</strong>. Je n’ai aucun problème sur la création en elle même du cycle jour/nuit, je peux d’ailleurs vous montrer un apperçu: </p>
<figure><img alt="" src="/media/galleries/3991/65e43a7e-02a6-4598-8576-982da59ca8b9.jpg"><figcaption>mon_super_globe</figcaption>
</figure>
<p>En fait, le projecteur de lumière se caractérise simplement ainsi:</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="kd">var</span> <span class="nb">sun</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">THREE</span><span class="p">.</span><span class="nx">DirectionalLight</span><span class="p">(</span><span class="mh">0xffffff</span><span class="p">,</span> <span class="mi">1</span><span class="p">);</span>
<span class="nb">sun</span><span class="p">.</span><span class="nx">position</span><span class="p">.</span><span class="nx">set</span><span class="p">(</span><span class="o">-</span><span class="mi">600</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1500</span><span class="p">);</span>
<span class="nx">scene</span><span class="p">.</span><span class="nx">add</span><span class="p">(</span><span class="nb">sun</span><span class="p">);</span>
</pre></div>
</td></tr></table></div>
<p>Comme on peut le voir, <strong>la position du soleil est fixe et suit un vecteur ne réprésentant pas la "réalité"</strong>.
J’ai trouvé <a href="https://github.com/k9/globe-viewer/blob/8dd972feab06866e7fbe0bdd063e5e73c6de28f5/app/js/coordinates.js">un projet</a> correspondant exactement à ce que je veux faire et j’en ai extrait un code pour l’appliquer sur mon globe: </p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="kd">function</span> <span class="nx">toRadians</span><span class="p">(</span><span class="nx">degrees</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">degrees</span> <span class="o">/</span> <span class="mi">180</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">PI</span>
<span class="p">}</span>
<span class="kd">function</span> <span class="nx">getJulianFromUnix</span><span class="p">(</span><span class="nx">time</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="p">((</span><span class="nx">time</span> <span class="o">/</span> <span class="mi">1000</span><span class="p">)</span> <span class="o">/</span> <span class="mf">86400.0</span><span class="p">)</span> <span class="o">+</span> <span class="mf">2440587.5</span>
<span class="p">}</span>
<span class="kd">function</span> <span class="nx">sunCoordinates</span><span class="p">(</span><span class="nx">time</span><span class="p">)</span> <span class="p">{</span>
<span class="kd">let</span> <span class="nx">D</span> <span class="o">=</span> <span class="nx">getJulianFromUnix</span><span class="p">(</span><span class="nx">time</span><span class="p">)</span> <span class="o">-</span> <span class="mi">2451545</span>
<span class="kd">let</span> <span class="nx">g</span> <span class="o">=</span> <span class="mf">357.529</span> <span class="o">+</span> <span class="mf">0.98560028</span> <span class="o">*</span> <span class="nx">D</span>
<span class="kd">let</span> <span class="nx">L</span> <span class="o">=</span> <span class="mf">280.459</span> <span class="o">+</span> <span class="mf">0.98564736</span> <span class="o">*</span> <span class="nx">D</span>
<span class="kd">let</span> <span class="nx">lambda</span> <span class="o">=</span> <span class="nx">L</span> <span class="o">+</span>
<span class="mf">1.915</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">sin</span><span class="p">(</span><span class="nx">toRadians</span><span class="p">(</span><span class="nx">g</span><span class="p">))</span> <span class="o">+</span>
<span class="mf">0.020</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">sin</span><span class="p">(</span><span class="nx">toRadians</span><span class="p">(</span><span class="mi">2</span> <span class="o">*</span> <span class="nx">g</span><span class="p">))</span>
<span class="kd">let</span> <span class="nx">e</span> <span class="o">=</span> <span class="mf">23.439</span> <span class="o">-</span> <span class="mf">0.00000036</span> <span class="o">*</span> <span class="nx">D</span>
<span class="kd">let</span> <span class="nx">y</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">cos</span><span class="p">(</span><span class="nx">toRadians</span><span class="p">(</span><span class="nx">e</span><span class="p">))</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">sin</span><span class="p">(</span><span class="nx">toRadians</span><span class="p">(</span><span class="nx">lambda</span><span class="p">))</span>
<span class="kd">let</span> <span class="nx">x</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">cos</span><span class="p">(</span><span class="nx">toRadians</span><span class="p">(</span><span class="nx">lambda</span><span class="p">))</span>
<span class="kd">let</span> <span class="nx">rightAscension</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">atan2</span><span class="p">(</span><span class="nx">y</span><span class="p">,</span> <span class="nx">x</span><span class="p">)</span>
<span class="kd">let</span> <span class="nx">declination</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">asin</span><span class="p">(</span>
<span class="nb">Math</span><span class="p">.</span><span class="nx">sin</span><span class="p">(</span><span class="nx">toRadians</span><span class="p">(</span><span class="nx">e</span><span class="p">))</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">sin</span><span class="p">(</span><span class="nx">toRadians</span><span class="p">(</span><span class="nx">lambda</span><span class="p">))</span>
<span class="p">)</span>
<span class="kd">let</span> <span class="nx">gmst</span> <span class="o">=</span> <span class="mf">18.697374558</span> <span class="o">+</span> <span class="mf">24.06570982441908</span> <span class="o">*</span> <span class="nx">D</span>
<span class="kd">let</span> <span class="nx">hourAngle</span> <span class="o">=</span> <span class="p">(</span><span class="nx">gmst</span> <span class="o">/</span> <span class="mi">24</span> <span class="o">*</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">PI</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span> <span class="o">-</span> <span class="nx">rightAscension</span>
<span class="k">return</span> <span class="p">{</span>
<span class="nx">hourAngle</span><span class="o">:</span> <span class="nx">hourAngle</span><span class="p">,</span>
<span class="nx">declination</span><span class="o">:</span> <span class="nx">declination</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="kd">var</span> <span class="nx">calculatedMoment</span> <span class="o">=</span> <span class="kd">function</span><span class="p">()</span> <span class="p">{</span>
<span class="k">return</span> <span class="nx">moment</span><span class="p">(</span><span class="k">new</span> <span class="nb">Date</span><span class="p">()).</span><span class="nx">utcOffset</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="p">}</span>
<span class="kd">var</span> <span class="nb">sun</span> <span class="o">=</span> <span class="nx">sunCoordinates</span><span class="p">(</span><span class="nb">parseInt</span><span class="p">(</span><span class="nx">calculatedMoment</span><span class="p">().</span><span class="nx">format</span><span class="p">(</span><span class="s1">'x'</span><span class="p">)));</span>
</pre></div>
</td></tr></table></div>
<p>Il m’affiche comme prévu:</p>
<div><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="p">{</span> <span class="nx">declination</span><span class="o">:</span> <span class="o">-</span><span class="mf">0.01716732820784288</span><span class="p">,</span> <span class="nx">hourAngle</span><span class="o">:</span> <span class="mf">39605.66185791371</span> <span class="p">}</span>
</pre></div>
</td></tr></table></div>
<p><strong>Mais comment réussir dans le cadre de mon projecteur à utiliser ces données pour reproduire la position du soleil ?</strong></p>
<p>Merci</p>