sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'refs/remotes/origin/master' into vulkan 

Former-commit-id: cc8208513fa7c16c0cd54fcbc5945d833142094e [formerly d55454a2e7326c6510e99d5a1a8ce8950c4d1455]
Former-commit-id: 105bc49e16a714bde5e9bac1ec076eaa63ae8381
This commit is contained in:
Lynix 2016-06-20 12:57:49 +02:00
parent 7d73f0dcad df4f11681a
commit 7649cbdd46
5 changed files with 177 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
examples/FirstScene/main.cpp
View File

@ -1,25 +1,27 @@
/*
** FirstScene - Première scène graphique
** Prérequis: Aucun
** Utilisation du module utilitaire et graphique
** Présente:
** - Création et gestion d'une fenêtre (Traitement des évènements clavier/souris)
** - Gestion du clavier (Récupération de l'état d'une touche)
** - Des outils pour afficher une scène basique via le chargement d'un modèle (et son affichage)
** - Éclairage directionnel
** - Gestion d'une caméra free-fly (Avec déplacement fluide)
** - Gestion basique d'une horloge
* FirstScene - Première scène graphique
* Prérequis: Aucun
* Utilisation du module utilitaire et graphique
** Présente :
* -Création et gestion d'une fenêtre (Traitement des évènements clavier/souris)
* -Gestion du clavier(Récupération de l'état d'une touche)
* -Des outils pour afficher une scène basique via le chargement d'un modèle (et son affichage)
* -Éclairage directionnel
* -Gestion d'une caméra free-fly (Avec déplacement fluide)
* -Gestion basique d'une horloge
* -Console
*/
#include <Nazara/Core/Clock.hpp> // Horloges
#include <Nazara/Lua.hpp> // Module de scripting
#include <Nazara/Graphics.hpp> // Module graphique
#include <Nazara/Renderer.hpp> // Module de rendu
#include <Nazara/Utility.hpp> // Module utilitaire
#include <NDK/Components/CameraComponent.hpp>
#include <NDK/Components/GraphicsComponent.hpp>
#include <NDK/Components/LightComponent.hpp>
#include <NDK/Components/NodeComponent.hpp>
#include <NDK/Systems/RenderSystem.hpp>
#include <NDK/Application.hpp>
#include <NDK/Components.hpp>
#include <NDK/Console.hpp>
#include <NDK/Systems.hpp>
#include <NDK/LuaAPI.hpp>
#include <NDK/Sdk.hpp>
#include <NDK/World.hpp>
#include <iostream>
@ -29,26 +31,15 @@ Nz::Vector3f DampedString(const Nz::Vector3f& currentPos, const Nz::Vector3f& ta
int main()
{
// Pour commencer, nous initialisons le SDK de Nazara, celui-ci va préparer le terrain en initialisant le moteur,
// les composants, systèmes, etc.
// NzInitializer est une classe RAII appelant Initialize dans son constructeur et Uninitialize dans son destructeur.
// Autrement dit, une fois ceci fait nous n'avons plus à nous soucier de la libération du moteur.
Nz::Initializer<Ndk::Sdk> nazara;
if (!nazara)
{
// Une erreur s'est produite dans l'initialisation d'un des modules
std::cout << "Failed to initialize Nazara, see NazaraLog.log for further informations" << std::endl;
std::getchar(); // On laise le temps de voir l'erreur
return EXIT_FAILURE;
}
// Ndk::Application est une classe s'occupant de l'initialisation du moteur ainsi que de la gestion de beaucoup de choses
Ndk::Application application;
// Nazara étant initialisé, nous pouvons créer le monde pour contenir notre scène.
// Dans un ECS, le monde représente bien ce que son nom indique, c'est l'ensemble de ce qui existe au niveau de l'application.
// Il contient les systèmes et les entités, ces dernières contiennent les composants.
// Il est possible d'utiliser plusieurs mondes au sein d'une même application, par exemple pour gérer un mélange de 2D et de 3D,
// mais nous verrons cela dans un prochain exemple.
Ndk::World world;
Ndk::WorldHandle world = application.AddWorld().CreateHandle();
// Nous pouvons maintenant ajouter des systèmes, mais dans cet exemple nous nous contenterons de ceux de base.
@ -73,7 +64,7 @@ int main()
Nz::SkyboxBackgroundRef skybox = Nz::SkyboxBackground::New(std::move(texture));
// Accédons maintenant au système de rendu faisant partie du monde
Ndk::RenderSystem& renderSystem = world.GetSystem<Ndk::RenderSystem>(); // Une assertion valide la précondition "le système doit faire partie du monde"
Ndk::RenderSystem& renderSystem = world->GetSystem<Ndk::RenderSystem>(); // Une assertion valide la précondition "le système doit faire partie du monde"
// Nous assignons ensuite notre skybox comme "fond par défaut" du système
// La notion "par défaut" existe parce qu'une caméra pourrait utiliser son propre fond lors du rendu,
@ -146,7 +137,7 @@ int main()
// Bien, nous avons un modèle valide, mais celui-ci ne consiste qu'en des informations de rendu, de matériaux et de textures.
// Commençons donc par créer une entité vide, cela se fait en demandant au monde de générer une nouvelle entité.
Ndk::EntityHandle spaceship = world.CreateEntity();
Ndk::EntityHandle spaceship = world->CreateEntity();
// Note: Nous ne récupérons pas l'entité directement mais un "handle" vers elle, ce dernier est un pointeur intelligent non-propriétaire.
// Pour des raisons techniques, le pointeur de l'entité peut venir à changer, ou l'entité être simplement détruite pour n'importe quelle raison.
@ -159,6 +150,7 @@ int main()
// Étant donné que par défaut, un NodeComponent se place en (0,0,0) sans rotation et avec une échelle de 1,1,1 et que cela nous convient,
// nous n'avons pas besoin d'agir sur le composant créé.
spaceship->AddComponent<Ndk::NodeComponent>();
//spaceship->AddComponent<Ndk::VelocityComponent>().linearVelocity.Set(-1.f, 0.f, 0.f);
// Bien, notre entité nouvellement créé dispose maintenant d'une position dans la scène, mais est toujours invisible
// Nous lui ajoutons donc un GraphicsComponent
@ -178,7 +170,7 @@ int main()
// Nous créons donc une seconde entité
// Note: La création d'entité est une opération légère au sein du moteur, mais plus vous aurez d'entités et plus le processeur devra travailler.
Ndk::EntityHandle camera = world.CreateEntity();
Ndk::EntityHandle camera = world->CreateEntity();
// Notre caméra a elle aussi besoin d'être positionnée dans la scène
Ndk::NodeComponent& cameraNode = camera->AddComponent<Ndk::NodeComponent>();
@ -188,6 +180,9 @@ int main()
// Et dispose d'un composant pour chaque point de vue de la scène, le CameraComponent
Ndk::CameraComponent& cameraComp = camera->AddComponent<Ndk::CameraComponent>();
// Ajoutons un composant écouteur, si nous venions à avoir du son
camera->AddComponent<Ndk::ListenerComponent>();
// Et on n'oublie pas de définir les plans délimitant le champs de vision
// (Seul ce qui se trouvera entre les deux plans sera rendu)
@ -208,7 +203,7 @@ int main()
// Nous allons créer une lumière directionnelle pour représenter la nébuleuse de notre skybox
// Encore une fois, nous créons notre entité
Ndk::EntityHandle nebulaLight = world.CreateEntity();
Ndk::EntityHandle nebulaLight = world->CreateEntity();
// Lui ajoutons une position dans la scène
Ndk::NodeComponent& nebulaLightNode = nebulaLight->AddComponent<Ndk::NodeComponent>();
@ -246,7 +241,7 @@ int main()
Nz::RenderTargetParameters parameters;
parameters.antialiasingLevel = 4;
Nz::RenderWindow window(mode, windowTitle, style, parameters);
Nz::RenderWindow& window = application.AddWindow<Nz::RenderWindow>(mode, windowTitle, style, parameters);
if (!window.IsValid())
{
std::cout << "Failed to create render window" << std::endl;
@ -272,8 +267,70 @@ int main()
bool smoothMovement = true;
Nz::Vector3f targetPos = cameraNode.GetPosition();
// Début de la boucle de rendu du programme
while (window.IsOpen())
// Pour ajouter une console à notre application, nous avons besoin d'un monde 2D pour gérer ces rendus
Ndk::WorldHandle world2D = application.AddWorld().CreateHandle();
world2D->GetSystem<Ndk::RenderSystem>().SetDefaultBackground(nullptr);
world2D->GetSystem<Ndk::RenderSystem>().SetGlobalUp(Nz::Vector3f::Down());
// Nous ajoutons une caméra comme précédement
Ndk::EntityHandle viewEntity = world2D->CreateEntity();
viewEntity->AddComponent<Ndk::NodeComponent>();
// À la différence que celui-ci effectuera une projection orthogonale
Ndk::CameraComponent& viewer = viewEntity->AddComponent<Ndk::CameraComponent>();
viewer.SetTarget(&window);
viewer.SetProjectionType(Nz::ProjectionType_Orthogonal);
// Nous créons un environnement Lua pour gérer nos scripts
Nz::LuaInstance lua;
// Faisons en sorte d'enregistrer les classes du moteur dans cet environnement
Ndk::LuaAPI::RegisterClasses(lua);
// Ensuite nous créons la console en elle-même
Ndk::Console console(*world2D, Nz::Vector2f(window.GetWidth(), window.GetHeight() / 4), lua);
// Nous redirigeons les logs vers cette console
Nz::Log::OnLogWriteType::ConnectionGuard logGuard = Nz::Log::OnLogWrite.Connect([&console] (const Nz::String& str)
{
console.AddLine(str);
});
// Nous réécrivons la fonction "print" du Lua pour la rediriger vers la console
lua.PushFunction([&console] (Nz::LuaInstance& instance)
{
Nz::StringStream stream;
unsigned int argCount = instance.GetStackTop();
instance.GetGlobal("tostring");
for (unsigned int i = 1; i <= argCount; ++i)
{
instance.PushValue(-1); // ToString
instance.PushValue(i); // Arg
instance.Call(1, 1);
std::size_t length;
const char* str = instance.CheckString(-1, &length);
if (i > 1)
stream << '\t';
stream << Nz::String(str, length);
instance.Pop(1);
}
console.AddLine(stream);
return 0;
});
lua.SetGlobal("print");
// Définissons quelques variables de base
lua.PushGlobal("Application", Ndk::Application::Instance());
lua.PushGlobal("Console", console.CreateHandle());
lua.PushGlobal("Spaceship", spaceship->CreateHandle());
lua.PushGlobal("World", world->CreateHandle());
// Début de la boucle de rendu du programme (s'occupant par exemple de mettre à jour le monde)
while (application.Run())
{
// Ensuite nous allons traiter les évènements (Étape indispensable pour la fenêtre)
Nz::WindowEvent event;
@ -283,6 +340,9 @@ int main()
{
case Nz::WindowEventType_MouseMoved: // La souris a bougé
{
if (console.IsVisible())
break;
// Gestion de la caméra free-fly (Rotation)
float sensitivity = 0.3f; // Sensibilité de la souris
@ -297,15 +357,18 @@ int main()
// Pour éviter que le curseur ne sorte de l'écran, nous le renvoyons au centre de la fenêtre
// Cette fonction est codée de sorte à ne pas provoquer d'évènement MouseMoved
Nz::Mouse::SetPosition(window.GetWidth()/2, window.GetHeight()/2, window);
Nz::Mouse::SetPosition(window.GetWidth() / 2, window.GetHeight() / 2, window);
break;
}
case Nz::WindowEventType_Quit: // L'utilisateur a cliqué sur la croix, ou l'OS veut terminer notre programme
window.Close(); // On demande la fermeture de la fenêtre (Qui aura lieu au prochain tour de boucle)
application.Quit();
break;
case Nz::WindowEventType_KeyPressed: // Une touche a été pressée !
if (console.IsVisible())
console.SendEvent(event);
if (event.key.code == Nz::Keyboard::Key::Escape)
window.Close();
else if (event.key.code == Nz::Keyboard::F1)
@ -318,6 +381,19 @@ int main()
else
smoothMovement = true;
}
else if (event.key.code == Nz::Keyboard::F9)
console.Show(!console.IsVisible());
break;
case Nz::WindowEventType_TextEntered:
{
if (console.IsVisible())
console.SendCharacter(event.text.character);
break;
}
case Nz::WindowEventType_Resized:
console.SetSize({float(event.size.width), event.size.height / 4.f});
break;
default:
@ -337,52 +413,48 @@ int main()
{
// Le temps écoulé en seconde depuis la dernière fois que ce bloc a été exécuté
float elapsedTime = updateAccumulator / 1000000.f;
std::cout << elapsedTime << std::endl;
// Vitesse de déplacement de la caméra
float cameraSpeed = 3.f * elapsedTime; // Trois mètres par seconde
// Si la touche espace est enfoncée, notre vitesse de déplacement est multipliée par deux
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Space))
cameraSpeed *= 2.f;
if (!console.IsVisible())
{
// Si la touche espace est enfoncée, notre vitesse de déplacement est multipliée par deux
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Space))
cameraSpeed *= 2.f;
// Pour que nos déplacement soient liés à la rotation de la caméra, nous allons utiliser
// les directions locales de la caméra
// Pour que nos déplacement soient liés à la rotation de la caméra, nous allons utiliser
// les directions locales de la caméra
// Si la flèche du haut ou la touche Z (vive ZQSD) est pressée, on avance
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Up) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Z))
targetPos += cameraNode.GetForward() * cameraSpeed;
// Si la flèche du haut ou la touche Z (vive ZQSD) est pressée, on avance
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Up) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Z))
targetPos += cameraNode.GetForward() * cameraSpeed;
// Si la flèche du bas ou la touche S est pressée, on recule
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Down) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::S))
targetPos += cameraNode.GetBackward() * cameraSpeed;
// Si la flèche du bas ou la touche S est pressée, on recule
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Down) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::S))
targetPos += cameraNode.GetBackward() * cameraSpeed;
// Etc...
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Left) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Q))
targetPos += cameraNode.GetLeft() * cameraSpeed;
// Etc...
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Left) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Q))
targetPos += cameraNode.GetLeft() * cameraSpeed;
// Etc...
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Right) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::D))
targetPos += cameraNode.GetRight() * cameraSpeed;
// Etc...
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::Right) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::D))
targetPos += cameraNode.GetRight() * cameraSpeed;
// Majuscule pour monter, notez l'utilisation d'une direction globale (Non-affectée par la rotation)
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::LShift) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::RShift))
targetPos += Nz::Vector3f::Up() * cameraSpeed;
// Majuscule pour monter, notez l'utilisation d'une direction globale (Non-affectée par la rotation)
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::LShift) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::RShift))
targetPos += Nz::Vector3f::Up() * cameraSpeed;
// Contrôle (Gauche ou droite) pour descendre dans l'espace global, etc...
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::LControl) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::RControl))
targetPos += Nz::Vector3f::Down() * cameraSpeed;
// Contrôle (Gauche ou droite) pour descendre dans l'espace global, etc...
if (Nz::Keyboard::IsKeyPressed(Nz::Keyboard::LControl) || Nz::Keyboard::IsKeyPressed(Nz::Keyboard::RControl))
targetPos += Nz::Vector3f::Down() * cameraSpeed;
}
cameraNode.SetPosition((smoothMovement) ? DampedString(cameraNode.GetPosition(), targetPos, elapsedTime) : targetPos, Nz::CoordSys_Global);
updateAccumulator = 0;
}
// Et maintenant pour rendre la scène, il nous suffit de mettre à jour le monde en lui envoyant le temps depuis la dernière mise à jour
// Note: La plupart des systèmes, à l'exception de celui de rendu, ont une fréquence de mise à jour fixe (modifiable)
// Il n'est donc pas nécessaire de limiter vous-même les mises à jour du monde
world.Update(elapsedUS / 1000000.f);
// Après avoir dessiné sur la fenêtre, il faut s'assurer qu'elle affiche cela
// Cet appel ne fait rien d'autre qu'échanger les buffers de rendu (Double Buffering)
window.Display();
@ -410,7 +482,7 @@ int main()
}
}
return EXIT_SUCCESS;
return EXIT_SUCCESS;
}
Nz::Vector3f DampedString(const Nz::Vector3f& currentPos, const Nz::Vector3f& targetPos, float frametime, float springStrength)
@ -430,7 +502,7 @@ Nz::Vector3f DampedString(const Nz::Vector3f& currentPos, const Nz::Vector3f& ta
if (Nz::NumberEquals(displacementLength, 0.f))
return currentPos;
float invDisplacementLength = 1.f/displacementLength;
float invDisplacementLength = 1.f / displacementLength;
const float dampConstant = 0.000065f; // Something v.small to offset 1/ displacement length

1
src/Nazara/Noise/NoiseBase.cpp
View File

@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Noise/NoiseBase.hpp>
#include <numeric>
#include <Nazara/Noise/Debug.hpp>
namespace Nz

4
src/Nazara/Noise/Perlin.cpp
View File

@ -76,9 +76,6 @@ namespace Nz
float Li1,Li2,Li3,Li4,Li5,Li6;
float s[2],t[2],u[2],v[2];
float Cx,Cy,Cz;
float nx,ny,nz;
float tmp;
float tempx,tempy,tempz;
xc = x * scale;
@ -157,7 +154,6 @@ namespace Nz
float s[4],t[4],u[4],v[4];
float Cx,Cy,Cz,Cw;
float tmp;
float tempx,tempy,tempz,tempw;
xc = x * scale;

28
src/Nazara/Noise/Simplex.cpp
View File

@ -12,12 +12,12 @@ namespace Nz
{
namespace
{
constexpr float s_SkewCoeff2D = 0.5f * (M_SQRT3 - 1.f);
constexpr float s_UnskewCoeff2D = (3.f - M_SQRT3)/6.f;
constexpr float s_SkewCoeff2D = 0.5f * (float(M_SQRT3) - 1.f);
constexpr float s_UnskewCoeff2D = (3.f - float(M_SQRT3))/6.f;
constexpr float s_SkewCoeff3D = 1.f / 3.f;
constexpr float s_UnskewCoeff3D = 1.f / 6.f;
constexpr float s_SkewCoeff4D = (M_SQRT5 - 1.f)/4.f;
constexpr float s_UnskewCoeff4D = (5.f - M_SQRT5)/20.f;
constexpr float s_SkewCoeff4D = (float(M_SQRT5) - 1.f)/4.f;
constexpr float s_UnskewCoeff4D = (5.f - float(M_SQRT5))/20.f;
}
Simplex::Simplex(unsigned int seed)
@ -39,7 +39,7 @@ namespace Nz
Vector2f unskewedDistToOrigin(xc - unskewedCubeOrigin.x, yc - unskewedCubeOrigin.y);
Vector2f off1;
Vector2ui off1;
if(unskewedDistToOrigin.x > unskewedDistToOrigin.y)
off1.Set(1, 0);
else
@ -47,7 +47,7 @@ namespace Nz
std::array<Vector2f, 3> d;
d[0] = -unskewedDistToOrigin;
d[1] = d[0] + off1 - Vector2f(s_UnskewCoeff2D);
d[1] = d[0] + Vector2f(off1) - Vector2f(s_UnskewCoeff2D);
d[2] = d[0] + Vector2f(1.f - 2.f * s_UnskewCoeff2D);
Vector2i offset(skewedCubeOrigin.x & 255, skewedCubeOrigin.y & 255);
@ -248,7 +248,7 @@ namespace Nz
int c;
float n1,n2,n3,n4,n5;
float c1,c2,c3,c4,c5,c6;
float c1,c2,c3,c4,c5;
float sum;
float unskewedCubeOriginx,unskewedCubeOriginy,unskewedCubeOriginz,unskewedCubeOriginw;
@ -280,13 +280,13 @@ namespace Nz
unskewedDistToOriginz = zc - unskewedCubeOriginz;
unskewedDistToOriginw = wc - unskewedCubeOriginw;
c1 = (unskewedDistToOriginx > unskewedDistToOriginy) ? 32 : 0;
c2 = (unskewedDistToOriginx > unskewedDistToOriginz) ? 16 : 0;
c3 = (unskewedDistToOriginy > unskewedDistToOriginz) ? 8 : 0;
c4 = (unskewedDistToOriginx > unskewedDistToOriginw) ? 4 : 0;
c5 = (unskewedDistToOriginy > unskewedDistToOriginw) ? 2 : 0;
c6 = (unskewedDistToOriginz > unskewedDistToOriginw) ? 1 : 0;
c = c1 + c2 + c3 + c4 + c5 + c6;
c = 0;
c += (unskewedDistToOriginx > unskewedDistToOriginy) ? 32 : 0;
c += (unskewedDistToOriginx > unskewedDistToOriginz) ? 16 : 0;
c += (unskewedDistToOriginy > unskewedDistToOriginz) ? 8 : 0;
c += (unskewedDistToOriginx > unskewedDistToOriginw) ? 4 : 0;
c += (unskewedDistToOriginy > unskewedDistToOriginw) ? 2 : 0;
c += (unskewedDistToOriginz > unskewedDistToOriginw) ? 1 : 0;
off1x = lookupTable[c][0] >= 3 ? 1 : 0;
off1y = lookupTable[c][1] >= 3 ? 1 : 0;

38
src/Nazara/Noise/Worley.cpp
View File

@ -14,10 +14,10 @@ namespace Nz
{
static constexpr std::array<float, 4> m_functionScales =
{
1.f / M_SQRT2,
0.5f / M_SQRT2,
0.5f / M_SQRT2,
0.5f / M_SQRT2
1.f / float(M_SQRT2),
0.5f / float(M_SQRT2),
0.5f / float(M_SQRT2),
0.5f / float(M_SQRT2)
};
}
Worley::Worley() :
@ -53,58 +53,60 @@ namespace Nz
SquareTest(x0,y0,xc,yc,featurePoints);
std::size_t functionIndex = static_cast<std::size_t>(m_function);
auto it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if(fractx < it->first)
SquareTest(x0 - 1,y0,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if(1.f - fractx < it->first)
SquareTest(x0 + 1,y0,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if(fracty < it->first)
SquareTest(x0,y0 - 1,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if (1.f - fracty < it->first)
SquareTest(x0,y0 + 1,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if (fractx < it->first && fracty < it->first)
SquareTest(x0 - 1, y0 - 1,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if (1.f - fractx < it->first && fracty < it->first)
SquareTest(x0 + 1, y0 - 1,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if (fractx < it->first && 1.f - fracty < it->first)
SquareTest(x0 - 1, y0 + 1,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
if(1.f - fractx < it->first && 1.f - fracty < it->first)
SquareTest(x0 + 1, y0 + 1,xc,yc,featurePoints);
it = featurePoints.begin();
std::advance(it, m_function);
std::advance(it, functionIndex);
return it->first * m_functionScales[m_function];
return it->first * m_functionScales[functionIndex];
}
float Worley::Get(float x, float y, float z, float scale) const
@ -127,16 +129,16 @@ namespace Nz
int ii = xi & 255;
int jj = yi & 255;
int seed = m_permutations[ii + m_permutations[jj]];
std::size_t seed = m_permutations[ii + m_permutations[jj]];
//On initialise notre rng avec seed
std::minstd_rand0 randomNumberGenerator(seed);
std::minstd_rand0 randomNumberGenerator(static_cast<unsigned int>(seed));
//On prend un nombre de points à déterminer dans le cube, compris entre 1 et 8
unsigned int m = (seed & 7) + 1;
std::size_t m = (seed & 7) + 1;
//On calcule les emplacements des différents points
for(unsigned int i(0) ; i < m ; ++i)
for(std::size_t i(0) ; i < m; ++i)
{
Nz::Vector2f featurePoint;
featurePoint.x = (randomNumberGenerator() & 1023) / 1023.f + static_cast<float>(xi);