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

Simplex & Perlin fully work now (all dimensions) + dynaTerrain removed temp

Browse Source
This commit is contained in:
Remi Beges
2012-06-07 13:10:58 +02:00
parent 5d7f8acbc8
commit ebba6adae4
23 changed files with 354 additions and 1124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
src/Nazara/DynaTerrain/Debug/Leaks.cpp
View File

@@ -1,29 +0,0 @@
// Copyright (C) 2012 AUTHORS
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/ModuleName/Config.hpp>
#if NAZARA_MODULENAME_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
#include <new>
void* operator new(std::size_t size) throw(std::bad_alloc)
{
return NzMemoryManager::Allocate(size, false);
}
void* operator new[](std::size_t size) throw(std::bad_alloc)
{
return NzMemoryManager::Allocate(size, true);
}
void operator delete(void* pointer) throw()
{
NzMemoryManager::Free(pointer, false);
}
void operator delete[](void* pointer) throw()
{
NzMemoryManager::Free(pointer, true);
}
#endif

57
src/Nazara/DynaTerrain/DynaTerrain.cpp
View File

@@ -1,57 +0,0 @@
// Copyright (C) 2012 AUTHORS
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/ModuleName/ModuleName.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/ModuleName/Config.hpp>
#include <Nazara/ModuleName/Debug.hpp>
NzModuleName::NzModuleName()
{
}
NzModuleName::~NzModuleName()
{
if (s_initialized)
Uninitialize();
}
bool NzModuleName::Initialize()
{
#if NAZARA_MODULENAME_SAFE
if (s_initialized)
{
NazaraError("ModuleName already initialized");
return true;
}
#endif
// Initialisation du module
s_initialized = true;
return true;
}
void NzModuleName::Uninitialize()
{
#if NAZARA_MODULENAME_SAFE
if (!s_initialized)
{
NazaraError("ModuleName not initialized");
return;
}
#endif
// Libération du module
s_initialized = false;
}
bool NzModuleName::IsInitialized()
{
return s_initialized;
}
bool NzModuleName::s_initialized = false;

317
src/Nazara/DynaTerrain/Node.cpp
View File

@@ -1,317 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#include "Node.hpp"
#include "QuadTree.hpp"
#include <stack>
//#include <Nazara/DynaTerrain/NoiseBase.hpp>
//#include <Nazara/DynaTerrain/Error.hpp>
//#include <Nazara/DynaTerrain/Config.hpp>
//#include <Nazara/DynaTerrain/Debug.hpp>
NzNode::NzNode(NzQuadTree* quad, NzNode* parent, const NzVector2f& center, const NzVector2f& size, nzDirection dir)
{
m_direction = dir;
m_center = center;
m_size = size;
m_isLeaf = false;
m_patchMemoryAllocated = false;
m_associatedQuadTree = quad;
m_topLeftLeaf = nullptr;
m_topRightLeaf = nullptr;
m_bottomLeftLeaf = nullptr;
m_bottomRightLeaf = nullptr;
if(parent == 0)
{
m_isRoot = true;
m_level = 0;
}
else
{
m_level = parent->GetLevel()+1;
m_parent = parent;
m_isRoot = false;
}
}
NzNode::~NzNode()
{
if(m_isLeaf)
m_associatedQuadTree->UnRegisterLeaf(this);
if(m_patchMemoryAllocated)
delete m_patch;
}
void NzNode::Subdivide()
{
m_isLeaf = false;
m_associatedQuadTree->UnRegisterLeaf(this);
if(m_topLeftLeaf == nullptr)
{
m_topLeftLeaf = new NzNode(m_associatedQuadTree,this,NzVector2f(m_center.x-m_size.x/2.f,
m_center.y+m_size.y/2.f),m_size/2.f,TOPLEFT);
m_topLeftLeaf->m_isLeaf = true;
m_associatedQuadTree->RegisterLeaf(m_topLeftLeaf);
}
if(m_topRightLeaf == nullptr)
{
m_topRightLeaf = new NzNode(m_associatedQuadTree,this,NzVector2f(m_center.x+m_size.x/2.f,
m_center.y+m_size.y/2.f),m_size/2.f,TOPRIGHT);
m_topRightLeaf->m_isLeaf = true;
m_associatedQuadTree->RegisterLeaf(m_topRightLeaf);
}
if(m_bottomLeftLeaf = nullptr)
{
m_bottomLeftLeaf = new NzNode(m_associatedQuadTree,this,NzVector2f(m_center.x-m_size.x/2.f,
m_center.y-m_size.y/2.f),m_size/2.f,BOTTOMLEFT);
m_bottomLeftLeaf->m_isLeaf = true;
m_associatedQuadTree->RegisterLeaf(m_bottomLeftLeaf);
}
if(m_bottomRightLeaf = nullptr)
{
m_bottomRightLeaf = new NzNode(m_associatedQuadTree,this,NzVector2f(m_center.x+m_size.x/2.f,
m_center.y-m_size.y/2.f),m_size/2.f,BOTTOMRIGHT);
m_bottomRightLeaf->m_isLeaf = true;
m_associatedQuadTree->RegisterLeaf(m_bottomRightLeaf);
}
}
void NzNode::Refine(bool eraseMemory)
{
m_isLeaf = true;
m_associatedQuadTree->RegisterLeaf(this);
if(eraseMemory)
{
/*
delete m_topLeftLeaf;
delete m_topRightLeaf;
delete m_bottomLeftLeaf;
delete m_bottomRightLeaf;
m_topLeftLeaf = nullptr;
m_topRightLeaf = nullptr;
m_bottomLeftLeaf = nullptr;
m_bottomRightLeaf = nullptr;*/
m_topLeftLeaf->DeletePatch();
m_topRightLeaf->DeletePatch();
m_bottomLeftLeaf->DeletePatch();
m_bottomRightLeaf->DeletePatch();
}
//else
//{
m_topLeftLeaf->m_isLeaf = false;
m_topRightLeaf->m_isLeaf = false;
m_bottomLeftLeaf->m_isLeaf = false;
m_bottomRightLeaf->m_isLeaf = false;
m_associatedQuadTree->UnRegisterLeaf(m_topLeftLeaf);
m_associatedQuadTree->UnRegisterLeaf(m_topRightLeaf);
m_associatedQuadTree->UnRegisterLeaf(m_bottomLeftLeaf);
m_associatedQuadTree->UnRegisterLeaf(m_bottomRightLeaf);
//}
}
void NzNode::CreatePatch(const NzVector2f& center, const NzVector2f& size)
{
m_patchMemoryAllocated = true;
m_patch = new NzPatch(center,size);
}
void NzNode::DeletePatch()
{
m_patchMemoryAllocated = false;
delete m_patch;
}
unsigned short int NzNode::GetLevel() const
{
return m_level;
}
bool NzNode::LocateNeighbor(nzDirection dir, NzNode* neighbor)
{
NzNode* temp = m_parent;
std::stack<nzDirection> treePath;
treePath.push(m_direction);
neighbor = nullptr;
switch(dir)
{
case TOP:
//Part 1
while(temp->m_direction != (BOTTOMLEFT || BOTTOMRIGHT || CENTER))
{
treePath.push(temp->m_direction);
temp = temp->m_parent;
}
//Part 2
if(temp->m_direction == BOTTOMLEFT)
temp = temp->m_parent->m_topLeftLeaf;
else if(temp->m_direction == BOTTOMRIGHT)
temp = temp->m_parent->m_topRightLeaf;
else if(temp->m_direction == CENTER)
return false;//No Neighbor existing
//Part 3
while(!temp->IsLeaf())
{
if(treePath.empty())
{
//Le chemin de redescente est plus court que celui de montée (level[node départ] < level[node d'arrivée])
break;
}
else
{
if(treePath.top() == TOPRIGHT)
temp = temp->m_bottomRightLeaf;
else if(treePath.top() == TOPLEFT)
temp = temp->m_bottomLeftLeaf;
else//D'uh ?
{
//Logger une erreur
return false;
}
treePath.pop();
}
}
neighbor = temp;
return true;
break;
case BOTTOM:
//Part 1
while(temp->m_direction != (TOPLEFT || TOPRIGHT || CENTER))
{
treePath.push(temp->m_direction);
temp = temp->m_parent;
}
//Part 2
if(temp->m_direction == TOPLEFT)
temp = temp->m_parent->m_bottomLeftLeaf;
else if(temp->m_direction == TOPRIGHT)
temp = temp->m_parent->m_bottomRightLeaf;
else if(temp->m_direction == CENTER)
return false;//No Neighbor existing
//Part 3
while(!temp->IsLeaf())
{
if(treePath.empty())
{
//Le chemin de redescente est plus court que celui de montée (level[node départ] < level[node d'arrivée])
break;
}
else
{
if(treePath.top() == BOTTOMRIGHT)
temp = temp->m_topRightLeaf;
else if(treePath.top() == BOTTOMLEFT)
temp = temp->m_topLeftLeaf;
else//D'uh ?
{
//Logger une erreur
return false;
}
treePath.pop();
}
}
neighbor = temp;
return true;
break;
case LEFT:
//Part 1
while(temp->m_direction != (TOPRIGHT || BOTTOMRIGHT || CENTER))
{
treePath.push(temp->m_direction);
temp = temp->m_parent;
}
//Part 2
if(temp->m_direction == TOPRIGHT)
temp = temp->m_parent->m_topLeftLeaf;
else if(temp->m_direction == BOTTOMRIGHT)
temp = temp->m_parent->m_bottomLeftLeaf;
else if(temp->m_direction == CENTER)
return false;//No Neighbor existing
//Part 3
while(!temp->IsLeaf())
{
if(treePath.top() == TOPLEFT)
temp = temp->m_topRightLeaf;
else if(treePath.top() == BOTTOMLEFT)
temp = temp->m_bottomRightLeaf;
else//D'uh ?
{
//Logger une erreur
return false;
}
treePath.pop();
}
neighbor = temp;
return true;
break;
case RIGHT:
//Part 1
while(temp->m_direction != (TOPLEFT || BOTTOMLEFT || CENTER))
{
treePath.push(temp->m_direction);
temp = temp->m_parent;
}
//Part 2
if(temp->m_direction == TOPLEFT)
temp = temp->m_parent->m_topRightLeaf;
else if(temp->m_direction == BOTTOMLEFT)
temp = temp->m_parent->m_bottomRightLeaf;
else if(temp->m_direction == CENTER)
return false;//No Neighbor existing
//Part 3
while(!temp->IsLeaf())
{
if(treePath.top() == TOPRIGHT)
temp = temp->m_topLeftLeaf;
else if(treePath.top() == BOTTOMRIGHT)
temp = temp->m_bottomLeftLeaf;
else//D'uh ?
{
//Logger une erreur
return false;
}
treePath.pop();
}
neighbor = temp;
return true;
break;
default :
return false;
break;
}
}
bool NzNode::IsLeaf() const
{
return m_isLeaf;
}
bool NzNode::IsRoot() const
{
return m_isRoot;
}

47
src/Nazara/DynaTerrain/Patch.cpp
View File

@@ -1,47 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#include "Patch.hpp"
//#include <Nazara/DynaTerrain/NoiseBase.hpp>
//#include <Nazara/DynaTerrain/Error.hpp>
//#include <Nazara/DynaTerrain/Config.hpp>
//#include <Nazara/DynaTerrain/Debug.hpp>
NzPatch::NzPatch(NzVector2f center, NzVector2f size)
{
m_center = center;
m_size = size;
}
NzPatch::~NzPatch()
{
//dtor
}
NzVector2f NzPatch::GetCenter() const
{
}
NzVector2f NzPatch::GetSize() const
{
}
bool NzPatch::IntersectsCircle(const NzVector2f& center, double radius)
{
}
bool NzPatch::IsContainedByCircle(const NzVector2f& center, double radius)
{
}
NzPatch* NzPatch::LocatePatch(const NzVector2f& position)
{
}

36
src/Nazara/DynaTerrain/QuadTree.cpp
View File

@@ -1,36 +0,0 @@
// Copyright (C) 2012 Rémi Bèges
// This file is part of the "Nazara Engine".
// For conditions of distribution and use, see copyright notice in Config.hpp
#include "QuadTree.hpp"
//#include <Nazara/DynaTerrain/NoiseBase.hpp>
//#include <Nazara/DynaTerrain/Error.hpp>
//#include <Nazara/DynaTerrain/Config.hpp>
//#include <Nazara/DynaTerrain/Debug.hpp>
NzQuadTree::NzQuadTree(const NzVector2f& terrainCenter, const NzVector2f& terrainSize)
{
root = new NzNode(this,0,terrainCenter,terrainSize);
}
void NzQuadTree::RegisterLeaf(NzNode* node)
{
leaves.push_back(node);
}
bool NzQuadTree::UnRegisterLeaf(NzNode* node)
{
leaves.remove(node);
}
NzNode* NzQuadTree::GetRootPtr()
{
return root;
}
NzQuadTree::~NzQuadTree()
{
//dtor
}

370
src/Nazara/Noise/NoiseMachine.cpp
View File

@@ -116,40 +116,43 @@ float NzNoiseMachine::Get3DPerlinNoiseValue(float x, float y, float z, float res
y /= res;
z /= res;
x0 = static_cast<int>(x);
y0 = static_cast<int>(y);
z0 = static_cast<int>(z);
x0 = fastfloor(x);
y0 = fastfloor(y);
z0 = fastfloor(z);
ii = x0 & 255;
jj = y0 & 255;
kk = z0 & 255;
gi0 = perm[ii + perm[jj + perm[kk]]] % 16;
gi1 = perm[ii + 1 + perm[jj + perm[kk]]] % 16;
gi2 = perm[ii + perm[jj + 1 + perm[kk]]] % 16;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk]]] % 16;
gi0 = perm[ii + perm[jj + perm[kk ]]] & 15;
gi1 = perm[ii + 1 + perm[jj + perm[kk ]]] & 15;
gi2 = perm[ii + perm[jj + 1 + perm[kk ]]] & 15;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk ]]] & 15;
gi4 = perm[ii + perm[jj + perm[kk + 1]]] % 16;
gi5 = perm[ii + 1 + perm[jj + perm[kk + 1]]] % 16;
gi6 = perm[ii + perm[jj + 1 + perm[kk + 1]]] % 16;
gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] % 16;
gi4 = perm[ii + perm[jj + perm[kk + 1]]] & 15;
gi5 = perm[ii + 1 + perm[jj + perm[kk + 1]]] & 15;
gi6 = perm[ii + perm[jj + 1 + perm[kk + 1]]] & 15;
gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] & 15;
temp.x = x-x0;
temp.y = y-y0;
temp.z = z-z0;
Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10);
Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10);
Cz = temp.z * temp.z * temp.z * (temp.z * (temp.z * 6 - 15) + 10);
s[0] = gradient3[gi0][0]*temp.x + gradient3[gi0][1]*temp.y + gradient3[gi0][2]*temp.z;
temp.x = x-(x0+1);
t[0] = gradient3[gi1][0]*temp.x + gradient3[gi1][1]*temp.y + gradient3[gi1][2]*temp.z;
temp.x = x-x0;
temp.y = y-(y0+1);
u[0] = gradient3[gi2][0]*temp.x + gradient3[gi2][1]*temp.y + gradient3[gi2][2]*temp.z;
temp.x = x-(x0+1);
v[0] = gradient3[gi3][0]*temp.x + gradient3[gi3][1]*temp.y + gradient3[gi3][2]*temp.z;
temp.x = x-x0;
u[0] = gradient3[gi2][0]*temp.x + gradient3[gi2][1]*temp.y + gradient3[gi2][2]*temp.z;
temp.y = y-y0;
temp.z = z-(z0+1);
s[1] = gradient3[gi4][0]*temp.x + gradient3[gi4][1]*temp.y + gradient3[gi4][2]*temp.z;
@@ -157,31 +160,20 @@ float NzNoiseMachine::Get3DPerlinNoiseValue(float x, float y, float z, float res
temp.x = x-(x0+1);
t[1] = gradient3[gi5][0]*temp.x + gradient3[gi5][1]*temp.y + gradient3[gi5][2]*temp.z;
temp.x = x-x0;
temp.y = y-(y0+1);
u[1] = gradient3[gi6][0]*temp.x + gradient3[gi6][1]*temp.y + gradient3[gi6][2]*temp.z;
temp.x = x-(x0+1);
temp.y = y-(y0+1);
v[1] = gradient3[gi7][0]*temp.x + gradient3[gi7][1]*temp.y + gradient3[gi7][2]*temp.z;
tmp = x-x0;
Cx = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10);
temp.x = x-x0;
u[1] = gradient3[gi6][0]*temp.x + gradient3[gi6][1]*temp.y + gradient3[gi6][2]*temp.z;
Li1 = s[0] + Cx*(t[0]-s[0]);
Li2 = u[0] + Cx*(v[0]-u[0]);
Li3 = s[1] + Cx*(t[1]-s[1]);
Li4 = u[1] + Cx*(v[1]-u[1]);
tmp = y-y0;
Cy = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10);
Li5 = Li1 + Cy*(Li2-Li1);
Li6 = Li3 + Cy*(Li4-Li3);
tmp = z-z0;
Cz = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10);
return Li5 + Cz*(Li6-Li5);
}
@@ -192,53 +184,57 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w,
z /= res;
w /= res;
x0 = static_cast<int>(x);
y0 = static_cast<int>(y);
z0 = static_cast<int>(z);
w0 = static_cast<int>(w);
x0 = fastfloor(x);
y0 = fastfloor(y);
z0 = fastfloor(z);
w0 = fastfloor(w);
ii = x0 & 255;
jj = y0 & 255;
kk = z0 & 255;
ll = w0 & 255;
gi0 = perm[ii + perm[jj + perm[kk + perm[ll ]]]] % 32;
gi1 = perm[ii + 1 + perm[jj + perm[kk + perm[ll ]]]] % 32;
gi2 = perm[ii + perm[jj + 1 + perm[kk + perm[ll ]]]] % 32;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll ]]]] % 32;
gi0 = perm[ii + perm[jj + perm[kk + perm[ll ]]]] & 31;
gi1 = perm[ii + 1 + perm[jj + perm[kk + perm[ll ]]]] & 31;
gi2 = perm[ii + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll ]]]] & 31;
gi4 = perm[ii + perm[jj + + perm[kk + 1 + perm[ll ]]]] % 32;
gi5 = perm[ii + 1 + perm[jj + + perm[kk + 1 + perm[ll ]]]] % 32;
gi6 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] % 32;
gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] % 32;
gi4 = perm[ii + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31;
gi5 = perm[ii + 1 + perm[jj + + perm[kk + 1 + perm[ll ]]]] & 31;
gi6 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31;
gi7 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll ]]]] & 31;
gi8 = perm[ii + perm[jj + perm[kk + perm[ll + 1]]]] % 32;
gi9 = perm[ii + 1 + perm[jj + perm[kk + perm[ll + 1]]]] % 32;
gi10 = perm[ii + perm[jj + 1 + perm[kk + perm[ll + 1]]]] % 32;
gi11 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll + 1]]]] % 32;
gi8 = perm[ii + perm[jj + perm[kk + perm[ll + 1]]]] & 31;
gi9 = perm[ii + 1 + perm[jj + perm[kk + perm[ll + 1]]]] & 31;
gi10 = perm[ii + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31;
gi11 = perm[ii + 1 + perm[jj + 1 + perm[kk + perm[ll + 1]]]] & 31;
gi12 = perm[ii + perm[jj + perm[kk + 1 + perm[ll + 1]]]] % 32;
gi13 = perm[ii + 1 + perm[jj + perm[kk + 1 + perm[ll + 1]]]] % 32;
gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32;
gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32;
gi12 = perm[ii + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31;
gi13 = perm[ii + 1 + perm[jj + perm[kk + 1 + perm[ll + 1]]]] & 31;
gi14 = perm[ii + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31;
gi15 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] & 31;
temp.x = x-x0;
temp.y = y-y0;
temp.z = z-z0;
temp.w = w-w0;
Cx = temp.x * temp.x * temp.x * (temp.x * (temp.x * 6 - 15) + 10);
Cy = temp.y * temp.y * temp.y * (temp.y * (temp.y * 6 - 15) + 10);
Cz = temp.z * temp.z * temp.z * (temp.z * (temp.z * 6 - 15) + 10);
Cw = temp.w * temp.w * temp.w * (temp.w * (temp.w * 6 - 15) + 10);
s[0] = gradient4[gi0][0]*temp.x + gradient4[gi0][1]*temp.y + gradient4[gi0][2]*temp.z + gradient4[gi0][3]*temp.w;
temp.x = x-(x0+1);
t[0] = gradient4[gi1][0]*temp.x + gradient4[gi1][1]*temp.y + gradient4[gi1][2]*temp.z + gradient4[gi1][3]*temp.w;
temp.x = x-x0;
temp.y = y-(y0+1);
u[0] = gradient4[gi2][0]*temp.x + gradient4[gi2][1]*temp.y + gradient4[gi2][2]*temp.z + gradient4[gi2][3]*temp.w;
temp.x = x-(x0+1);
v[0] = gradient4[gi3][0]*temp.x + gradient4[gi3][1]*temp.y + gradient4[gi3][2]*temp.z + gradient4[gi3][3]*temp.w;
temp.x = x-x0;
u[0] = gradient4[gi2][0]*temp.x + gradient4[gi2][1]*temp.y + gradient4[gi2][2]*temp.z + gradient4[gi2][3]*temp.w;
temp.y = y-y0;
temp.z = z-(z0+1);
s[1] = gradient4[gi4][0]*temp.x + gradient4[gi4][1]*temp.y + gradient4[gi4][2]*temp.z + gradient4[gi4][3]*temp.w;
@@ -246,14 +242,13 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w,
temp.x = x-(x0+1);
t[1] = gradient4[gi5][0]*temp.x + gradient4[gi5][1]*temp.y + gradient4[gi5][2]*temp.z + gradient4[gi5][3]*temp.w;
temp.x = x-x0;
temp.y = y-(y0+1);
u[1] = gradient4[gi6][0]*temp.x + gradient4[gi6][1]*temp.y + gradient4[gi6][2]*temp.z + gradient4[gi6][3]*temp.w;
temp.x = x-(x0+1);
v[1] = gradient4[gi7][0]*temp.x + gradient4[gi7][1]*temp.y + gradient4[gi7][2]*temp.z + gradient4[gi7][3]*temp.w;
temp.x = x-x0;
u[1] = gradient4[gi6][0]*temp.x + gradient4[gi6][1]*temp.y + gradient4[gi6][2]*temp.z + gradient4[gi6][3]*temp.w;
temp.y = y-y0;
temp.z = z-z0;
temp.w = w-(w0+1);
@@ -262,14 +257,12 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w,
temp.x = x-(x0+1);
t[2] = gradient4[gi9][0]*temp.x + gradient4[gi9][1]*temp.y + gradient4[gi9][2]*temp.z + gradient4[gi9][3]*temp.w;
temp.x = x-x0;
temp.y = y-(y0+1);
u[2] = gradient4[gi10][0]*temp.x + gradient4[gi10][1]*temp.y + gradient4[gi10][2]*temp.z + gradient4[gi10][3]*temp.w;
temp.x = x-(x0+1);
v[2] = gradient4[gi11][0]*temp.x + gradient4[gi11][1]*temp.y + gradient4[gi11][2]*temp.z + gradient4[gi11][3]*temp.w;
temp.x = x-x0;
u[2] = gradient4[gi10][0]*temp.x + gradient4[gi10][1]*temp.y + gradient4[gi10][2]*temp.z + gradient4[gi10][3]*temp.w;
temp.y = y-y0;
temp.z = z-(z0+1);
s[3] = gradient4[gi12][0]*temp.x + gradient4[gi12][1]*temp.y + gradient4[gi12][2]*temp.z + gradient4[gi12][3]*temp.w;
@@ -277,15 +270,11 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w,
temp.x = x-(x0+1);
t[3] = gradient4[gi13][0]*temp.x + gradient4[gi13][1]*temp.y + gradient4[gi13][2]*temp.z + gradient4[gi13][3]*temp.w;
temp.x = x-x0;
temp.y = y-(y0+1);
u[3] = gradient4[gi14][0]*temp.x + gradient4[gi14][1]*temp.y + gradient4[gi14][2]*temp.z + gradient4[gi14][3]*temp.w;
temp.x = x-(x0+1);
v[3] = gradient4[gi15][0]*temp.x + gradient4[gi15][1]*temp.y + gradient4[gi15][2]*temp.z + gradient4[gi15][3]*temp.w;
tmp = x-x0;
Cx = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10);
temp.x = x-x0;
u[3] = gradient4[gi14][0]*temp.x + gradient4[gi14][1]*temp.y + gradient4[gi14][2]*temp.z + gradient4[gi14][3]*temp.w;
Li1 = s[0] + Cx*(t[0]-s[0]);
Li2 = u[0] + Cx*(v[0]-u[0]);
@@ -296,23 +285,14 @@ float NzNoiseMachine::Get4DPerlinNoiseValue(float x, float y, float z, float w,
Li7 = s[3] + Cx*(t[3]-s[3]);
Li8 = u[3] + Cx*(v[3]-u[3]);
tmp = y-y0;
Cy = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10);
Li9 = Li1 + Cy*(Li2-Li1);
Li10 = Li3 + Cy*(Li4-Li3);
Li11 = Li5 + Cy*(Li6-Li5);
Li12 = Li7 + Cy*(Li8-Li7);
tmp = z-z0;
Cz = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10);
Li13 = Li9 + Cz*(Li10-Li9);
Li14 = Li11 + Cz*(Li12-Li11);
tmp = w-w0;
Cw = tmp * tmp * tmp * (tmp * (tmp * 6 - 15) + 10);
return Li13 + Cw*(Li14-Li13);
}
@@ -323,11 +303,13 @@ float NzNoiseMachine::Get2DSimplexNoiseValue(float x, float y, float res)
x /= res;
y /= res;
skewedCubeOrigin.x = fastfloor(x + (x + y) * SkewCoeff2D);
skewedCubeOrigin.y = fastfloor(y + (x + y) * SkewCoeff2D);
sum = (x + y) * SkewCoeff2D;
skewedCubeOrigin.x = fastfloor(x + sum);
skewedCubeOrigin.y = fastfloor(y + sum);
unskewedCubeOrigin.x = skewedCubeOrigin.x - (skewedCubeOrigin.x + skewedCubeOrigin.y) * UnskewCoeff2D;
unskewedCubeOrigin.y = skewedCubeOrigin.y - (skewedCubeOrigin.x + skewedCubeOrigin.y) * UnskewCoeff2D;
sum = (skewedCubeOrigin.x + skewedCubeOrigin.y) * UnskewCoeff2D;
unskewedCubeOrigin.x = skewedCubeOrigin.x - sum;
unskewedCubeOrigin.y = skewedCubeOrigin.y - sum;
unskewedDistToOrigin.x = x - unskewedCubeOrigin.x;
unskewedDistToOrigin.y = y - unskewedCubeOrigin.y;
@@ -343,9 +325,7 @@ float NzNoiseMachine::Get2DSimplexNoiseValue(float x, float y, float res)
off1.y = 1;
}
d1.x = unskewedCubeOrigin.x - x;
d1.y = unskewedCubeOrigin.y - y;
d1 = - unskewedDistToOrigin;
d2.x = d1.x + off1.x - UnskewCoeff2D;
d2.y = d1.y + off1.y - UnskewCoeff2D;
@@ -356,9 +336,9 @@ float NzNoiseMachine::Get2DSimplexNoiseValue(float x, float y, float res)
ii = skewedCubeOrigin.x & 255;
jj = skewedCubeOrigin.y & 255;
gi0 = perm[ii + perm[jj]] & 7;
gi0 = perm[ii + perm[jj ]] & 7;
gi1 = perm[ii + off1.x + perm[jj + off1.y]] & 7;
gi2 = perm[ii + 1 + perm[jj + 1]] & 7;
gi2 = perm[ii + 1 + perm[jj + 1 ]] & 7;
c1 = 0.5 - d1.x * d1.x - d1.y * d1.y;
c2 = 0.5 - d2.x * d2.x - d2.y * d2.y;
@@ -388,21 +368,23 @@ float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float re
y /= res;
z /= res;
Origin.x = fastfloor(x + (x + y + z) * SkewCoeff3D);
Origin.y = fastfloor(y + (x + y + z) * SkewCoeff3D);
Origin.z = fastfloor(z + (x + y + z) * SkewCoeff3D);
sum = (x + y + z) * SkewCoeff3D;
skewedCubeOrigin.x = fastfloor(x + sum);
skewedCubeOrigin.y = fastfloor(y + sum);
skewedCubeOrigin.z = fastfloor(z + sum);
A.x = Origin.x - (Origin.x + Origin.y + Origin.z) * UnskewCoeff3D;
A.y = Origin.y - (Origin.x + Origin.y + Origin.z) * UnskewCoeff3D;
A.z = Origin.z - (Origin.x + Origin.y + Origin.z) * UnskewCoeff3D;
sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z) * UnskewCoeff3D;
unskewedCubeOrigin.x = skewedCubeOrigin.x - sum;
unskewedCubeOrigin.y = skewedCubeOrigin.y - sum;
unskewedCubeOrigin.z = skewedCubeOrigin.z - sum;
IsoOriginDist.x = x - A.x;
IsoOriginDist.y = y - A.y;
IsoOriginDist.z = z - A.z;
unskewedDistToOrigin.x = x - unskewedCubeOrigin.x;
unskewedDistToOrigin.y = y - unskewedCubeOrigin.y;
unskewedDistToOrigin.z = z - unskewedCubeOrigin.z;
if(IsoOriginDist.x >= IsoOriginDist.y)
if(unskewedDistToOrigin.x >= unskewedDistToOrigin.y)
{
if(IsoOriginDist.y >= IsoOriginDist.z)
if(unskewedDistToOrigin.y >= unskewedDistToOrigin.z)
{
off1.x = 1;
off1.y = 0;
@@ -411,7 +393,7 @@ float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float re
off2.y = 1;
off2.z = 0;
}
else if(IsoOriginDist.x >= IsoOriginDist.z)
else if(unskewedDistToOrigin.x >= unskewedDistToOrigin.z)
{
off1.x = 1;
off1.y = 0;
@@ -432,7 +414,7 @@ float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float re
}
else
{
if(IsoOriginDist.y < IsoOriginDist.z)
if(unskewedDistToOrigin.y < unskewedDistToOrigin.z)
{
off1.x = 0;
off1.y = 0;
@@ -441,7 +423,7 @@ float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float re
off2.y = 1;
off2.z = 1;
}
else if(IsoOriginDist.x < IsoOriginDist.z)
else if(unskewedDistToOrigin.x < unskewedDistToOrigin.z)
{
off1.x = 0;
off1.y = 1;
@@ -461,35 +443,28 @@ float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float re
}
}
d1.x = A.x - x;
d1.y = A.y - y;
d1.z = A.z - z;
d1 = unskewedDistToOrigin;
d2.x = d1.x + off1.x - UnskewCoeff3D;
d2.y = d1.y + off1.y - UnskewCoeff3D;
d2.z = d1.z + off1.z - UnskewCoeff3D;
d2.x = d1.x - off1.x + UnskewCoeff3D;
d2.y = d1.y - off1.y + UnskewCoeff3D;
d2.z = d1.z - off1.z + UnskewCoeff3D;
d3.x = d1.x + off2.x - 2*UnskewCoeff3D;
d3.y = d1.y + off2.y - 2*UnskewCoeff3D;
d3.z = d1.z + off2.z - 2*UnskewCoeff3D;
d3.x = d1.x - off2.x + 2*UnskewCoeff3D;
d3.y = d1.y - off2.y + 2*UnskewCoeff3D;
d3.z = d1.z - off2.z + 2*UnskewCoeff3D;
d4.x = d1.x + 1.0 - 3*UnskewCoeff3D;
d4.y = d1.y + 1.0 - 3*UnskewCoeff3D;
d4.z = d1.z + 1.0 - 3*UnskewCoeff3D;
d4.x = d1.x - 1.0 + 3*UnskewCoeff3D;
d4.y = d1.y - 1.0 + 3*UnskewCoeff3D;
d4.z = d1.z - 1.0 + 3*UnskewCoeff3D;
ii = Origin.x & 255;
jj = Origin.y & 255;
kk = Origin.z & 255;
ii = skewedCubeOrigin.x & 255;
jj = skewedCubeOrigin.y & 255;
kk = skewedCubeOrigin.z & 255;
gi0 = perm[ii + perm[jj + perm[kk]]] % 12;
gi0 = perm[ii + perm[jj + perm[kk ]]] % 12;
gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z]]] % 12;
gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z]]] % 12;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1]]] % 12;
n1 = gradient3[gi0][0] * d1.x + gradient3[gi0][1] * d1.y + gradient3[gi0][2] * d1.z;
n2 = gradient3[gi1][0] * d2.x + gradient3[gi1][1] * d2.y + gradient3[gi1][2] * d2.z;
n3 = gradient3[gi2][0] * d3.x + gradient3[gi2][1] * d3.y + gradient3[gi2][2] * d3.z;
n4 = gradient3[gi3][0] * d4.x + gradient3[gi3][1] * d4.y + gradient3[gi3][2] * d4.z;
gi3 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 ]]] % 12;
c1 = 0.6 - d1.x * d1.x - d1.y * d1.y - d1.z * d1.z;
c2 = 0.6 - d2.x * d2.x - d2.y * d2.y - d2.z * d2.z;
@@ -497,20 +472,26 @@ float NzNoiseMachine::Get3DSimplexNoiseValue(float x, float y, float z, float re
c4 = 0.6 - d4.x * d4.x - d4.y * d4.y - d4.z * d4.z;
if(c1 < 0)
c1 = 0;
n1 = 0;
else
n1 = c1*c1*c1*c1*(gradient3[gi0][0] * d1.x + gradient3[gi0][1] * d1.y + gradient3[gi0][2] * d1.z);
if(c2 < 0)
c2 = 0;
n2 = 0;
else
n2 = c2*c2*c2*c2*(gradient3[gi1][0] * d2.x + gradient3[gi1][1] * d2.y + gradient3[gi1][2] * d2.z);
if(c3 < 0)
c3 = 0;
n3 = 0;
else
n3 = c3*c3*c3*c3*(gradient3[gi2][0] * d3.x + gradient3[gi2][1] * d3.y + gradient3[gi2][2] * d3.z);
if(c4 < 0)
c4 = 0;
n4 = 0;
else
n4 = c4*c4*c4*c4*(gradient3[gi3][0] * d4.x + gradient3[gi3][1] * d4.y + gradient3[gi3][2] * d4.z);
n1 = c1*c1*c1*n1;
n2 = c2*c2*c2*n2;
n3 = c3*c3*c3*n3;
n4 = c4*c4*c4*n4;
return (n1+n2+n3+n4)*17.6995;
return (n1+n2+n3+n4)*32;
}
float NzNoiseMachine::Get4DSimplexNoiseValue(float x, float y, float z, float w, float res)
@@ -520,27 +501,29 @@ float NzNoiseMachine::Get4DSimplexNoiseValue(float x, float y, float z, float w,
z /= res;
w /= res;
Origin.x = fastfloor(x + (x + y + z + w) * SkewCoeff4D);
Origin.y = fastfloor(y + (x + y + z + w) * SkewCoeff4D);
Origin.z = fastfloor(z + (x + y + z + w) * SkewCoeff4D);
Origin.w = fastfloor(w + (x + y + z + w) * SkewCoeff4D);
sum = (x + y + z + w) * SkewCoeff4D;
skewedCubeOrigin.x = fastfloor(x + sum);
skewedCubeOrigin.y = fastfloor(y + sum);
skewedCubeOrigin.z = fastfloor(z + sum);
skewedCubeOrigin.w = fastfloor(w + sum);
A.x = Origin.x - (Origin.x + Origin.y + Origin.z + Origin.w) * UnskewCoeff4D;
A.y = Origin.y - (Origin.x + Origin.y + Origin.z + Origin.w) * UnskewCoeff4D;
A.z = Origin.z - (Origin.x + Origin.y + Origin.z + Origin.w) * UnskewCoeff4D;
A.w = Origin.w - (Origin.x + Origin.y + Origin.z + Origin.w) * UnskewCoeff4D;
sum = (skewedCubeOrigin.x + skewedCubeOrigin.y + skewedCubeOrigin.z + skewedCubeOrigin.w) * UnskewCoeff4D;
unskewedCubeOrigin.x = skewedCubeOrigin.x - sum;
unskewedCubeOrigin.y = skewedCubeOrigin.y - sum;
unskewedCubeOrigin.z = skewedCubeOrigin.z - sum;
unskewedCubeOrigin.w = skewedCubeOrigin.w - sum;
IsoOriginDist.x = x - A.x;
IsoOriginDist.y = y - A.y;
IsoOriginDist.z = z - A.z;
IsoOriginDist.w = w - A.w;
unskewedDistToOrigin.x = x - unskewedCubeOrigin.x;
unskewedDistToOrigin.y = y - unskewedCubeOrigin.y;
unskewedDistToOrigin.z = z - unskewedCubeOrigin.z;
unskewedDistToOrigin.w = w - unskewedCubeOrigin.w;
c1 = (IsoOriginDist.x > IsoOriginDist.y) ? 32 : 0;
c2 = (IsoOriginDist.x > IsoOriginDist.z) ? 16 : 0;
c3 = (IsoOriginDist.y > IsoOriginDist.z) ? 8 : 0;
c4 = (IsoOriginDist.x > IsoOriginDist.w) ? 4 : 0;
c5 = (IsoOriginDist.y > IsoOriginDist.w) ? 2 : 0;
c6 = (IsoOriginDist.z > IsoOriginDist.w) ? 1 : 0;
c1 = (unskewedDistToOrigin.x > unskewedDistToOrigin.y) ? 32 : 0;
c2 = (unskewedDistToOrigin.x > unskewedDistToOrigin.z) ? 16 : 0;
c3 = (unskewedDistToOrigin.y > unskewedDistToOrigin.z) ? 8 : 0;
c4 = (unskewedDistToOrigin.x > unskewedDistToOrigin.w) ? 4 : 0;
c5 = (unskewedDistToOrigin.y > unskewedDistToOrigin.w) ? 2 : 0;
c6 = (unskewedDistToOrigin.z > unskewedDistToOrigin.w) ? 1 : 0;
c = c1 + c2 + c3 + c4 + c5 + c6;
off1.x = lookupTable4D[c][0] >= 3 ? 1 : 0;
@@ -558,48 +541,39 @@ float NzNoiseMachine::Get4DSimplexNoiseValue(float x, float y, float z, float w,
off3.z = lookupTable4D[c][2] >= 1 ? 1 : 0;
off3.w = lookupTable4D[c][3] >= 1 ? 1 : 0;
d1.x = A.x - x;
d1.y = A.y - y;
d1.z = A.z - z;
d1.w = A.w - w;
d1 = unskewedDistToOrigin;
d2.x = d1.x + off1.x - UnskewCoeff4D;
d2.y = d1.y + off1.y - UnskewCoeff4D;
d2.z = d1.z + off1.z - UnskewCoeff4D;
d2.w = d1.w + off1.w - UnskewCoeff4D;
d2.x = d1.x - off1.x + UnskewCoeff4D;
d2.y = d1.y - off1.y + UnskewCoeff4D;
d2.z = d1.z - off1.z + UnskewCoeff4D;
d2.w = d1.w - off1.w + UnskewCoeff4D;
d3.x = d1.x + off2.x - 2*UnskewCoeff4D;
d3.y = d1.y + off2.y - 2*UnskewCoeff4D;
d3.z = d1.z + off2.z - 2*UnskewCoeff4D;
d3.w = d1.w + off2.w - 2*UnskewCoeff4D;
d3.x = d1.x - off2.x + 2*UnskewCoeff4D;
d3.y = d1.y - off2.y + 2*UnskewCoeff4D;
d3.z = d1.z - off2.z + 2*UnskewCoeff4D;
d3.w = d1.w - off2.w + 2*UnskewCoeff4D;
d4.x = d1.x + off3.x - 3*UnskewCoeff4D;
d4.y = d1.y + off3.y - 3*UnskewCoeff4D;
d4.z = d1.z + off3.z - 3*UnskewCoeff4D;
d4.w = d1.w + off3.w - 3*UnskewCoeff4D;
d4.x = d1.x - off3.x + 3*UnskewCoeff4D;
d4.y = d1.y - off3.y + 3*UnskewCoeff4D;
d4.z = d1.z - off3.z + 3*UnskewCoeff4D;
d4.w = d1.w - off3.w + 3*UnskewCoeff4D;
d5.x = d1.x + 1.0 - 4*UnskewCoeff4D;
d5.y = d1.y + 1.0 - 4*UnskewCoeff4D;
d5.z = d1.z + 1.0 - 4*UnskewCoeff4D;
d5.w = d1.w + 1.0 - 4*UnskewCoeff4D;
d5.x = d1.x - 1.0 + 4*UnskewCoeff4D;
d5.y = d1.y - 1.0 + 4*UnskewCoeff4D;
d5.z = d1.z - 1.0 + 4*UnskewCoeff4D;
d5.w = d1.w - 1.0 + 4*UnskewCoeff4D;
ii = Origin.x & 255;
jj = Origin.y & 255;
kk = Origin.z & 255;
ll = Origin.w & 255;
ii = skewedCubeOrigin.x & 255;
jj = skewedCubeOrigin.y & 255;
kk = skewedCubeOrigin.z & 255;
ll = skewedCubeOrigin.w & 255;
gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] % 32;
gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z + perm[ll + off1.w]]]] % 32;
gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z + perm[ll + off2.w]]]] % 32;
gi3 = perm[ii + off3.x + perm[jj + off3.y + perm[kk + off3.z + perm[ll + off3.w]]]] % 32;
gi0 = perm[ii + perm[jj + perm[kk + perm[ll]]]] & 31;
gi1 = perm[ii + off1.x + perm[jj + off1.y + perm[kk + off1.z + perm[ll + off1.w]]]] & 31;
gi2 = perm[ii + off2.x + perm[jj + off2.y + perm[kk + off2.z + perm[ll + off2.w]]]] & 31;
gi3 = perm[ii + off3.x + perm[jj + off3.y + perm[kk + off3.z + perm[ll + off3.w]]]] & 31;
gi4 = perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32;
n1 = gradient4[gi0][0]*d1.x + gradient4[gi0][1]*d1.y + gradient4[gi0][2]*d1.z + gradient4[gi0][3]*d1.w;
n2 = gradient4[gi1][0]*d2.x + gradient4[gi1][1]*d2.y + gradient4[gi1][2]*d2.z + gradient4[gi1][3]*d2.w;
n3 = gradient4[gi2][0]*d3.x + gradient4[gi2][1]*d3.y + gradient4[gi2][2]*d3.z + gradient4[gi2][3]*d3.w;
n4 = gradient4[gi3][0]*d4.x + gradient4[gi3][1]*d4.y + gradient4[gi3][2]*d4.z + gradient4[gi3][3]*d4.w;
n5 = gradient4[gi4][0]*d5.x + gradient4[gi4][1]*d5.y + gradient4[gi4][2]*d5.z + gradient4[gi4][3]*d5.w;
c1 = 0.6 - d1.x*d1.x - d1.y*d1.y - d1.z*d1.z - d1.w*d1.w;
c2 = 0.6 - d2.x*d2.x - d2.y*d2.y - d2.z*d2.z - d2.w*d2.w;
c3 = 0.6 - d3.x*d3.x - d3.y*d3.y - d3.z*d3.z - d3.w*d3.w;
@@ -607,23 +581,31 @@ float NzNoiseMachine::Get4DSimplexNoiseValue(float x, float y, float z, float w,
c5 = 0.6 - d5.x*d5.x - d5.y*d5.y - d5.z*d5.z - d5.w*d5.w;
if(c1 < 0)
c1 = 0;
n1 = 0;
else
n1 = c1*c1*c1*c1*(gradient4[gi0][0]*d1.x + gradient4[gi0][1]*d1.y + gradient4[gi0][2]*d1.z + gradient4[gi0][3]*d1.w);
if(c2 < 0)
c2 = 0;
n2 = 0;
else
n2 = c2*c2*c2*c2*(gradient4[gi1][0]*d2.x + gradient4[gi1][1]*d2.y + gradient4[gi1][2]*d2.z + gradient4[gi1][3]*d2.w);
if(c3 < 0)
c3 = 0;
n3 = 0;
else
n3 = c3*c3*c3*c3*(gradient4[gi2][0]*d3.x + gradient4[gi2][1]*d3.y + gradient4[gi2][2]*d3.z + gradient4[gi2][3]*d3.w);
if(c4 < 0)
c4 = 0;
n4 = 0;
else
n4 = c4*c4*c4*c4*(gradient4[gi3][0]*d4.x + gradient4[gi3][1]*d4.y + gradient4[gi3][2]*d4.z + gradient4[gi3][3]*d4.w);
if(c5 < 0)
c5 = 0;
n5 = 0;
else
n5 = c5*c5*c5*c5*(gradient4[gi4][0]*d5.x + gradient4[gi4][1]*d5.y + gradient4[gi4][2]*d5.z + gradient4[gi4][3]*d5.w);
n1 = c1*c1*c1*n1;
n2 = c2*c2*c2*n2;
n3 = c3*c3*c3*n3;
n4 = c4*c4*c4*n4;
n5 = c5*c5*c5*n5;
return (n1+n2+n3+n4+n5)*17.6995;
return (n1+n2+n3+n4+n5)*27.0;
}
//------------------------------ CELL ------------------------------