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
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 ^^.
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
Tout d'abord, un nouveau bruit (2d et 3d pour l'instant) tout bête de rajouté (pour l'instant 2d et 3d) :
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.
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 :
Le même bruit, mais dont les coordonnées d'entrée ont été déformées préalablement par une octave de simplex :
Et une ébauche de soleil, c'est une simple capture d'écran mais c'est animé et ça tourne à 20 fps, sans grande optimisation !
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 !
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.
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
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
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.
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;
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 :
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
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 !
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).
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é...
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):
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
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.
× 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.
Mes articles | Nazara Engine | Discord NaN | Ma chaîne Twitch (programmation)
"J'aimerai faire un jeu, mais pas un gros jeu hein. Un petit truc simple du style MMO."
Mes articles | Nazara Engine | Discord NaN | Ma chaîne Twitch (programmation)
Mes articles | Nazara Engine | Discord NaN | Ma chaîne Twitch (programmation)