Partage
  • Partager sur Facebook
  • Partager sur Twitter

ZNoise

Bibliotheque de bruits pour la génération procedurale

    18 avril 2012 à 10:18:09

    Pour faire du temps réel, ça dépend du nombre de bruits utilisés et de leur vitesses respectives, du nombre de dimensions, et puis de la puissance de l'ordinateur. Sur un pc récent à plusieurs coeurs, en faisant du multithreading tu devrais y parvenir avec quelque chose de très simple. J'avais fait divers benchmark (sans multithread), pour le perlin 2d j'obtenais 156000000 appels sur une durée de 14 secondes, ce qui revient à générer 23 images par secondes, pas encore du temps réel mais presque.
    Après il y a bien sûr la solution de la génération sur gpu, qui peut considérablement accélérer ça. Mais c'est vrai qu'en général c'est une bien meilleure idée de faire la génération qu'à l'initialisation ;)

    Bien vu pour le ~ ;)
    • Partager sur Facebook
    • Partager sur Twitter
      20 avril 2012 à 21:02:01

      En fait, je pense à une map très grande pour laquelle il est difficile d’avoir toute la map en RAM. Du coup, le mieux serait de générer en temps réel, mais peut-être pas tout : simplement générer les alentours au fur et à mesure et supprimer les zones qui s’éloignent de trop devrait être faisable d’après tes benchmarks. J’essaierai ça quand j’aurai le temps ^^.
      • Partager sur Facebook
      • Partager sur Twitter
        20 avril 2012 à 21:19:45

        Ah oui mais dans ce cas tu n'as pas besoin de faire du temps réel, il te faut juste faire tourner la génération de la map dans un autre thread et ça sera assez rapide sans problème ;)
        • Partager sur Facebook
        • Partager sur Twitter
          22 avril 2012 à 18:30:11

          Oui, c’est ça, mais il faut quand même que tout ce qui est visible soit généré à temps, donc il faut quand même que ça soit assez rapide.
          • Partager sur Facebook
          • Partager sur Twitter
            23 avril 2012 à 9:44:17

            Salut :)

            Ça a vraiment l'air génial tout ça!
            je l'utiliserai dans mon prochain projet. ^^
            • Partager sur Facebook
            • Partager sur Twitter
              31 mai 2012 à 16:15:51

              Quelques news :

              Tout d'abord, un nouveau bruit (2d et 3d pour l'instant) tout bête de rajouté (pour l'instant 2d et 3d) :

              Image utilisateur

              La taille des carrés est réglable comme tout les autres bruits, via le paramètre "resolution". D'ailleurs pour ceux qui demandaient le cell-noise, je pensais tout d'abord que c'était ça, donc dites-moi si ça correspond ou pas...

              Ensuite, ZNoise est en train d'être ajouté au moteur de jeu Nazara, créé par Lynix, en dévellopement (mais déjà bien avancé et prometteur). Tout le monde est le bienvenu pour contribuer au moteur, rajouter un module est extrêmement simple.

              A cette occasion, une nouvelle architecture a été implémentée. La classe unique donnant accès à toutes les fonctions existent toujours, mais il existe désormais aussi une classe par bruit et par dimension (Perlin2D, Simplex2D, Perlin3D, etc.), ce qui a permit diverses optimisations supplémentaires.

              Bonne journée à tous.
              • Partager sur Facebook
              • Partager sur Twitter
                12 juin 2012 à 12:30:43

                ZNoise est mort, vive Nazara Noise !

                Nazara est un moteur de jeu jeu (créé par Lynix), qui se dote désormais d'un module de bruit, codé par votre serviteur ! Pour l'occasion, l'architecture a été revue, désormais plus flexible et plus efficace. La classe globale a été conservée, mais des classes uniques pour chaque fonction ont été créées, plus optimisées et moins gourmandes en mémoire !

                Voici d'ailleurs les premières images générées par NzNoise :

                Un mélange d'octaves de simplex appellé Ridged Multifractal :
                Image utilisateur

                Le même bruit, mais dont les coordonnées d'entrée ont été déformées préalablement par une octave de simplex :
                Image utilisateur

                Et une ébauche de soleil, c'est une simple capture d'écran mais c'est animé et ça tourne à 20 fps, sans grande optimisation !
                Image utilisateur

                La keymap utilisée a encore besoin d'être retravaillée, mais en combinant la première image pour générer les protubérances et la troisième pour le soleil en lui même, il y a moyen de produire un soleil digne de ce nom !
                • Partager sur Facebook
                • Partager sur Twitter
                  13 juin 2012 à 11:29:53

                  En un seul mot : BRAVO !
                  • Partager sur Facebook
                  • Partager sur Twitter
                    13 juin 2012 à 13:40:47

                    NzNoise sera-t-il encore disponible sans Nazara engine?¿?
                    • Partager sur Facebook
                    • Partager sur Twitter
                    L'être humain, contrairement aux geeks qui ne sont de toute façon pas des êtres humains, est un animal social taillé pour vivre en "meute".
                      13 juin 2012 à 14:16:30

                      Oui j'ai mis à jour le dépôt git de znoise avec les toutes dernières améliorations, mais ce dépôt n'inclueras pas la nouvelle architecture (avec les nouvelles classes optimisées). Ca imposerait de mettre en place un moyen de compiler la lib (premake, cmake ou autre), chose qui est déjà faite dans Nazara, et dont je suis relativement novice en la matière.

                      Je suis conscient que vous vouliez utiliser znoise à part (combiné à la sfml par exemple), mais à terme c'est encore plus simple d'avoir la lib faisant déjà partie d'un moteur de jeu.
                      • Partager sur Facebook
                      • Partager sur Twitter
                        13 juin 2012 à 16:15:55

                        Honnêtement rien n'empêche d'utiliser le noyau de Nazara et le module Noise conjointement à la SFML, le noyau a été conçu pour être utilisable dans n'importe quelle situation (Même pour un site web) et avec n'importe quelle bibliothèque ;)
                        • Partager sur Facebook
                        • Partager sur Twitter
                        Nazara Engine | Discord NaN ! (Chat dédié à la programmation) | Ma chaîne Twitch (développement)
                          13 juillet 2012 à 2:58:41

                          Hey!

                          Est-ce qu'il serait possible d'avoir une petite doc sur les différentes fonctions de bruit: utilité des paramètres et intervalle des valeurs de retour.
                          Parce qu'en fait j'essaie tant bien que mal de générer un lot de heightmaps, et je me retrouve avec des espèces de trous noirs (ou blancs) liés au fait que sur certains bruits les valeurs de retour sont comprises entre -1 et 1, d'autres dépassent le 1...
                          Par exemple, dans
                          Get2DHybridMultiFractalNoiseValue(float x, float y,double H, double lacunarity, double octaves, double resolution);
                          

                          A quoi correspondent les paramètres H, lacunarity et octave?

                          J'utilise aussi une version un peu vieille du moteur (qui date de zNoise), promis j'upgrade dans la semaine ;)

                          Merci d'avance :)
                          • Partager sur Facebook
                          • Partager sur Twitter

                          "J'aimerai faire un jeu, mais pas un gros jeu hein. Un petit truc simple du style MMO."

                            13 juillet 2012 à 14:48:21

                            L'ancien wiki de znoise est toujours en ligne, et la page qui s'intéresse est celle-ci : https://github.com/Overdrivr/ZNoise/wi [...] ing-FBM-Noise

                            Bon par contre c'est en anglais j'ai eu un peu la flemme de l'écrire aussi en français, mais en gros les bruits complexes sont formés par l'addition pondérée de bruits simples (perlin, simplex, etc.) de résolution différentes. Un empilement de couches de bruits simples en quelque sorte (chacune de ces couches est appelée octave).

                            H (paramètre de Hurst) : contrôle le poids de chaque octave. Plus une octave a du poids, plus elle sera visible. En pratique, une grande valeur de H va adoucir les "hautes fréquences" (les octaves dont la résolution est la plus petite), donnant l'aspect d'un terrain assez lisse. Au contraire, une grande valeur va donner un effet chaotique. Un bon intervalle de travail : ]0;2]

                            lacunarity : contrôle l'intervalle de "fréquence" (= résolution) entre deux octaves successives. Précise si ça ne te paraît pas clair. Un bon intervalle : [2;20]

                            octaves : tout simplement le nombre de couches de bruits simples. Plus il y en a, plus c'est lent.

                            Pour la doc, t'as raison, je rajouterais quelque chose de consistant sur le wiki de Nazara quand j'aurais un peu plus le temps (dur avec les vacances ^^)

                            Et pour le problème d'intervalle, c'est un bug, mais je pense savoir comment le résoudre. Je l'avais un peu oublié celui-là :-° Je vais le résoudre rapidement, c'est assez génant. Tu fais bien de passer à la nouvelle version, elle corrige pas mal de bug (notamment l'implémentation de simplex) et est plus optimisée.
                            • Partager sur Facebook
                            • Partager sur Twitter
                              2 octobre 2012 à 23:40:27

                              Reprise des hostilités !

                              J'ai apporté quelques modifications à l'architecture, qui je pense est quasi-définitive car elle s'adapte très bien à l'utilisation du module dans un éditeur de node et dans un module de terrain. La classe NoiseMachine a disparue pour diverses raisons (principalement sa redondance sur toutes les autres classes), en retour un bruit complexe (FBM2D) a été implémenté, disposant de la même interface que les bruits simples, ce qui facilite l'utilisation. Cette implé corrige le problème du bruit retournant des valeurs supérieures à 1 ou inférieures à -1 !
                              L'implémentation en 2D et 3D ainsi que l'ajout du bruit complexe hybrid multifractal va suivre très rapidement.

                              Un exemple de code :
                              #include <Nazara/Noise/FBM2D.hpp>
                              #include <Nazara/Noise/Perlin2D.hpp>
                              
                              int main()
                              {
                                  //On crée un perlin 2d 
                                  NzPerlin2D perlin2;
                                  //On lui affecte pour nombre racine 1313
                                  perlin2.SetNewSeed(1313);
                                  //On mélange sa table de permutation
                                      // pour rappel, le nombre racine permet de mélanger pseudo-aléatoirement 
                                      //la table de permutation, qui est elle utilisée dans le calcul de la valeur du bruit
                                  perlin2.ShufflePermutationTable();
                              
                              
                                  //On crée un fbm 2d, utilisant perlin comme source et 1313 comme racine
                                  NzFBM2D fbm2(PERLIN,1313);
                                  //On donne des valeurs aux paramètres du fbm (facultatif)
                                  fbm2.SetLacunarity(2.5);
                                  fbm2.SetHurstParameter(0.8);
                                  fbm2.SetOctavesNumber(5);
                              
                              
                                  //On imagine parcourir les pixels d'une image de taille 800*600
                                  for(int x(0) ; x < 800 ; ++x)
                                      for(int y(0) ; y < 600 ; ++y)
                                      {
                                           //La valeur du bruit pour chaque pixel
                                           float r = perlin2.GetValue(x,y,20.f)*127.5f + 127.5f;//[-1;1] -> [0;255]
                                           float g = fbm2.GetValue(x,y,140.f)*127.5f + 127.5f; //[-1;1] -> [0;255]
                                           //...
                                      }
                              


                              L'ensemble des bruits se voient enrichir d'une méthode SetResolution pour prédéfinir une résolution :

                              perlin2.SetResolution(30.f);
                              
                              for(int x(0) ; x < 800 ; ++x)
                                      for(int y(0) ; y < 600 ; ++y)
                                      {
                                      //Utilise la resolution predefinie (=30.f)
                                      float r = perlin2.GetBasicValue(x,y);
                                      //Pas ici par contre (où la résolution est 20.f)
                                      float r = perlin2.GetValue(x,y,20.f);
                                      }
                              


                              Enfin un dernière fonctionnalité, vraiment mineure, mais qui peut être un peu utile, c'est la possibilité d'affecter un gain et un offset à la valeur renvoyée par GetBasicValue, pour cela utiliser la fonction GetMappedValue :

                              perlin2.SetGain(255.f/2);
                              perlin2.SetOffset(1.f);
                              
                              for(int x(0) ; x < 800 ; ++x)
                                      for(int y(0) ; y < 600 ; ++y)
                                      {
                                       float r = perlin2.GetMappedValue(x,y);//Utilise la resolution prédéfinie, ainsi que le gain et l'offset, selon la formule : 
                                       //GetMappedValue(x,y) = (GetValue(x,y,resolution_predefinie) + offset)*gain;
                              


                              Lien vers le dernier commit : https://github.com/Overdrivr/NazaraEng [...] 91d46cdf582ab

                              Prochaine étape : finir l'ajout de classe, compléter le wiki (tutoriels !), module pour faire du mixage, module de terrain (une à la fois !)
                              • Partager sur Facebook
                              • Partager sur Twitter
                                11 février 2013 à 14:53:45

                                J'ai profité du weekend pour implémenter le "Worley Noise", aussi appelé "Cellular Noise", car il ressemble parfois à des amas de cellules. Démonstration :

                                Worley F1 (F1 = calculé avec la distance au point de grille le plus proche):

                                Worley F2  (F2 = calculé avec la distance au SECOND point de grille le plus proche) :

                                Pour simuler des amas de neurones, il suffit de mettre un fort gain (multiplier la valeur retournée du bruit par 1000 environ) et de limiter la valeur à 255 (couleur blanche) :

                                En mettant un gain à 2000, ça produit le fameux effet "cellules" :

                                L'algorithme de ce bruit est assez simple, et a de grandes similarités avec le bruit de Perlin. Le papier qui m'a permis de l'implémenter est à cette adresse :

                                http://www.rhythmiccanvas.com/research/papers/worley.pdf

                                Par ailleurs, j'ai légèrement simplifié certaines opérations du papier que j'ai jugé inutiles, utilisé une table de permutation au lieu de la fonction de hash proposé, et remplacé un appel au rng par un ET logique. Par contre, contrairement à une implémentation naïve, mon implémentation n'implique pas de prégénérer des positions de points, tout est fait à la volée. Le bruit est donc, comme Perlin et Simplex, définit pour toutes valeurs de x,y. Il ne renvoie par contre que des valeurs comprises entre 0 et 1.

                                 Niveaux perfs, je n'ai fait aucun benchmark, mais on peut s'attendre à quelque chose de proche au perlin.

                                Ce bruit est je pense très utile car il permet de faire un grand nombre de choses facilement. Il peut être utilisé pour générer des textures de roches, des champs étoilés, positionner des arbres pour une foret procéduralement, et bien plus encore.

                                J'implémenterais la version 3D et 4D lorsque je trouverais le temps, étant pas mal accaparé par Dynaterrain en ce moment...

                                EDIT : lien vers le commit : https://github.com/Overdrivr/NazaraEngine/commit/cceabc483670105251a3afa705d3b224e01929ad

                                -
                                Edité par OveRdrivR 11 février 2013 à 15:01:19

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  11 février 2013 à 19:22:11

                                  Un grand bravo, j'ai hâte de voir ce qu'on pourra en sortir :)

                                  Tiens je vois que dans le code tu fais beaucoup de "this->" pour accéder aux membres de la classe, un ancien habitué au Java ? :)

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  Nazara Engine | Discord NaN ! (Chat dédié à la programmation) | Ma chaîne Twitch (développement)
                                    11 février 2013 à 21:04:00

                                    T'as pas idée comme j'ai hâte de pouvoir scripter tout ça en lua, recompiler pour régénérer l'image c'est tellement casse pied ^^ Et non, jamais fait du java de ma vie, C++ born and raised !

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      12 février 2013 à 0:19:12

                                      Scripter le tout en Lua, ça peut se faire, j'y travaille (Même si je suis à cheval sur ça et la gestion des Scene).

                                      Je me demandais parce qu'en C++, le "this->" est optionnel et je le vois assez rarement utilisé (En fait je vois surtout ça venant de gens ayant fait du Java).

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      Nazara Engine | Discord NaN ! (Chat dédié à la programmation) | Ma chaîne Twitch (développement)
                                        19 juin 2013 à 0:17:41

                                        Je suit Nazarra depuis ses premiers pas et c'est intéressant de voir naître un éco-système autour de ce moteur qui gagne chaque jour.

                                        Lynix a écrit:

                                        Je me demandais parce qu'en C++, le "this->" est optionnel et je le vois assez rarement utilisé (En fait je vois surtout ça venant de gens ayant fait du Java).

                                         En java ils sont aussi optionnels :). Ce serait plutôt pour ceux qui viennent de PHP. De plus i s’agit exactement de la même syntaxe en PHP.

                                        Je pense qu'il est préférable d'éviter les appel qualifiés avec "this". C'est bien plus lisible (et moins ambigu et sujet aux erreurs) d'utiliser des noms de variables locales différents des noms d'attribut et d'avoir des appel non qualifié...



                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          4 août 2015 à 14:37:58

                                          Je déterre le sujet, j’espère que je ne vais pas me faire voler dans les plumes.

                                          Mais c'est pour la bonne cause, le module de bruit a subi un gros rafraîchissement. L'architecture est bien meilleure, et plus extensible.

                                          Ce n'est pas encore merge dans le dépôt original de Lynix, seulement dans mon fork pour l'instant.

                                          https://github.com/Overdrivr/NazaraEngine/commits/master (Regardez les derniers commits pour ceux que ca interesse)

                                          Avant, il y avait une classe par dimension pour les bruits complexes (FBM2D, FBM3D,..HybridMultifractal2D,etc.), il n'y en a désormais qu'une seule (FBM, HybridMultifractal). Le module est plus facilement extensible (+ de dimensions, + facile de rajouter des bruits simples)

                                          Ensuite, des exemples sont en préparation. Le premier exemple est quasi fini (manque une broutille):

                                          https://github.com/Overdrivr/NazaraEngine/blob/44a46c994a67778809ba11834ffa2fa362f472ce/examples/NoiseBasis/main.cpp

                                          Enfin, je vais faire une priorité d’écrire la documentation.

                                          -
                                          Edité par OveRdrivR 4 août 2015 à 14:38:46

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            11 novembre 2015 à 0:28:35

                                            Deuxième couche de peinture pour ZNoise

                                            D'abord, une première release de la librairie, avec sources pre-compilées.

                                            https://github.com/Overdrivr/ZNoise/releases/tag/1.0.0

                                            Ensuite, passage sous Gradle pour gérer le build. Desormais il suffit d'avoir un compilateur GCC qui supporte un minimum C++11 (la plupart désormais) pour compiler ZNoise. (Sous windows, il faut aussi rajouter le sous-dossier bin\ du compilateur dans le PATH Windows).

                                            Trois commandes a exécuter dans une console pointant sur le dossier racine ZNoise\

                                            gradlew build
                                            gradlew installDebugExampleExecutable

                                            Pour lancer le programme d'exemple il suffit alors 

                                            build\install\examplesExecutable\debug\examples.bat

                                            Cela lance le premier exemple, qui montre comment utiliser Perlin2D pour générer une image puis l'enregistrer sur le disque. Cette demo utilise la librairie de gestion d'images CImg, mais il n'y a rien a installer, les sources sont déjà la.

                                            Enfin, une bonne mise a jour du fichier README.



                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              2 décembre 2015 à 23:04:45

                                              Il y a des choses en preparation pour ZNoise, en voici un avant gout tres sommaire...

                                              node graph editor

                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                3 décembre 2015 à 1:32:36

                                                Une version NodeJS?

                                                :waw:

                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                L'être humain, contrairement aux geeks qui ne sont de toute façon pas des êtres humains, est un animal social taillé pour vivre en "meute".
                                                  3 décembre 2015 à 11:01:43

                                                  Une version javascript en effet, bien vu ;) Apres, j’hésite encore a porter a la main le code en javascript ou a utiliser ça:

                                                  http://kripken.github.io/emscripten-site/index.html

                                                  Ça me permettrait de convertir automatiquement le C++ en javascript optimisé. 

                                                  Sinon, le screenshot est un éditeur de nœuds pour assembler des bruits de manière ludique et sympa.

                                                  Je posterai l’avancée au fur et a mesure, a terme l’éditeur sera disponible en ligne pour ceux qui veulent bidouiller avec.

                                                  -
                                                  Edité par OveRdrivR 8 décembre 2015 à 8:46:53

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter

                                                  ZNoise

                                                  × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                  × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                  • Editeur
                                                  • Markdown