/****************************************
* Procedure qui stocke une valeur
* dans la pyramide. Gere la liste des
* places
***************************************/
inline void SetValueAt(int val, int lig, int diag)
{
/* Variables */
int t,ind;
/* S'il y a deja un nombre a cette case, on le retire de la liste des pris */
t = ValueAt(lig, diag);
ind = Indice(lig, diag);
if((t != 0) && place[t-1] == ind)
place[t-1] = OUT_OF_PYR;
/* On place l'element dans la pyramide */
elements[ind] = val;
/* On le marque comme etant pris */
place[val-1] = ind;
/* Maintien de la liste des places */
if(progres < ind+1) progres = ind+1;
}
/****************************************
* Renvoie TRUE si val est dans la pyramide
* avant la position (lig, diag)
***************************************/
inline int Contains(int val, int lig, int diag)
{
/* On regarde dans la table si val est place avant
* 1 <= val <= nb_elem */
return(place[val-1] <= Indice(lig, diag));
}
/****************************************
* Fonction d'acces a une valeur de la
* pyramide (parcours par diagonale)
***************************************/
inline int ValueAt(int lig, int diag)
{
return elements[Indice(lig, diag)];
}
/**
* Devuelve true si y sólo e pertenece al conjunto.
* Notar que no es requerido que e pertenezca al rango de c.
* Implementa la función PERTENECE?(in c: conjAcotado, in e: nat) -> res : bool
* PRE: { true }
* POS: { res = e € ConjSuby(c) }
* Complejidad: O(1)
*/
bool ConjAcotado::Pertenece(Nat e) const {
return EnRango(e) and pertenencia.Definido(Indice(e));
}
/**
* Agrega un elemento al conjunto.
* Implementa la función AGREGAR(in/out c: conjAcotado, in e : nat)
* PRE: { c = c_0 ^ Infimo(c) <= e <= Supremo(c) }
* POS: { c = Ag(e, c_0) }
* Complejidad: O(1)
*/
void ConjAcotado::Agregar(Nat e) {
assert(EnRango(e));
if (!Pertenece(e)) {
pertenencia.Definir(Indice(e), elementos.AgregarRapido(e));
}
}
/**
* Elimina a de c, si es que estaba.
* Observar que no es requerido que e pertenezca al rango de c.
* Implementa la función ELIMINAR(in/out c: conjAcotado, in e: nat)
* PRE: { c = c_0 }
* POS: { ConjSuby(c) = ConjSuby(c_0) \ {e} ^ Rango(c) = Rango(c_0) }
* Complejidad: O(1)
*/
void ConjAcotado::Eliminar(Nat e) {
if (EnRango(e) && Pertenece(e)) {
pertenencia[Indice(e)].EliminarSiguiente();
pertenencia.Borrar(Indice(e));
}
}
/*
** Noise function, returning the Perlin Noise at a given point
*/
float Noise (const float x,
const float y,
const float z,
const float t)
{
/* The unit hypercube containing the point */
const int x1 = (int) (x > 0 ? x : x - 1);
const int y1 = (int) (y > 0 ? y : y - 1);
const int z1 = (int) (z > 0 ? z : z - 1);
const int t1 = (int) (t > 0 ? t : t - 1);
const int x2 = x1 + 1;
const int y2 = y1 + 1;
const int z2 = z1 + 1;
const int t2 = t1 + 1;
/* The 16 corresponding gradients */
const char * g0000 = gradient[Indice (x1, y1, z1, t1)];
const char * g0001 = gradient[Indice (x1, y1, z1, t2)];
const char * g0010 = gradient[Indice (x1, y1, z2, t1)];
const char * g0011 = gradient[Indice (x1, y1, z2, t2)];
const char * g0100 = gradient[Indice (x1, y2, z1, t1)];
const char * g0101 = gradient[Indice (x1, y2, z1, t2)];
const char * g0110 = gradient[Indice (x1, y2, z2, t1)];
const char * g0111 = gradient[Indice (x1, y2, z2, t2)];
const char * g1000 = gradient[Indice (x2, y1, z1, t1)];
const char * g1001 = gradient[Indice (x2, y1, z1, t2)];
const char * g1010 = gradient[Indice (x2, y1, z2, t1)];
const char * g1011 = gradient[Indice (x2, y1, z2, t2)];
const char * g1100 = gradient[Indice (x2, y2, z1, t1)];
const char * g1101 = gradient[Indice (x2, y2, z1, t2)];
const char * g1110 = gradient[Indice (x2, y2, z2, t1)];
const char * g1111 = gradient[Indice (x2, y2, z2, t2)];
/* The 16 vectors */
const float dx1 = x - x1;
const float dx2 = x - x2;
const float dy1 = y - y1;
const float dy2 = y - y2;
const float dz1 = z - z1;
const float dz2 = z - z2;
const float dt1 = t - t1;
const float dt2 = t - t2;
/* The 16 dot products */
const float b0000 = Dot_prod(dx1, g0000[0], dy1, g0000[1],
dz1, g0000[2], dt1, g0000[3]);
const float b0001 = Dot_prod(dx1, g0001[0], dy1, g0001[1],
dz1, g0001[2], dt2, g0001[3]);
const float b0010 = Dot_prod(dx1, g0010[0], dy1, g0010[1],
dz2, g0010[2], dt1, g0010[3]);
const float b0011 = Dot_prod(dx1, g0011[0], dy1, g0011[1],
dz2, g0011[2], dt2, g0011[3]);
const float b0100 = Dot_prod(dx1, g0100[0], dy2, g0100[1],
dz1, g0100[2], dt1, g0100[3]);
const float b0101 = Dot_prod(dx1, g0101[0], dy2, g0101[1],
dz1, g0101[2], dt2, g0101[3]);
const float b0110 = Dot_prod(dx1, g0110[0], dy2, g0110[1],
dz2, g0110[2], dt1, g0110[3]);
const float b0111 = Dot_prod(dx1, g0111[0], dy2, g0111[1],
dz2, g0111[2], dt2, g0111[3]);
const float b1000 = Dot_prod(dx2, g1000[0], dy1, g1000[1],
dz1, g1000[2], dt1, g1000[3]);
const float b1001 = Dot_prod(dx2, g1001[0], dy1, g1001[1],
dz1, g1001[2], dt2, g1001[3]);
const float b1010 = Dot_prod(dx2, g1010[0], dy1, g1010[1],
dz2, g1010[2], dt1, g1010[3]);
const float b1011 = Dot_prod(dx2, g1011[0], dy1, g1011[1],
dz2, g1011[2], dt2, g1011[3]);
const float b1100 = Dot_prod(dx2, g1100[0], dy2, g1100[1],
dz1, g1100[2], dt1, g1100[3]);
const float b1101 = Dot_prod(dx2, g1101[0], dy2, g1101[1],
dz1, g1101[2], dt2, g1101[3]);
const float b1110 = Dot_prod(dx2, g1110[0], dy2, g1110[1],
dz2, g1110[2], dt1, g1110[3]);
const float b1111 = Dot_prod(dx2, g1111[0], dy2, g1111[1],
dz2, g1111[2], dt2, g1111[3]);
/* Then the interpolations, down to the result */
const float idx1 = Spline5 (dx1);
const float idy1 = Spline5 (dy1);
const float idz1 = Spline5 (dz1);
const float idt1 = Spline5 (dt1);
const float b111 = Linear (b1110, b1111, idt1);
const float b110 = Linear (b1100, b1101, idt1);
const float b101 = Linear (b1010, b1011, idt1);
const float b100 = Linear (b1000, b1001, idt1);
const float b011 = Linear (b0110, b0111, idt1);
const float b010 = Linear (b0100, b0101, idt1);
const float b001 = Linear (b0010, b0011, idt1);
const float b000 = Linear (b0000, b0001, idt1);
const float b11 = Linear (b110, b111, idz1);
const float b10 = Linear (b100, b101, idz1);
const float b01 = Linear (b010, b011, idz1);
const float b00 = Linear (b000, b001, idz1);
const float b1 = Linear (b10, b11, idy1);
const float b0 = Linear (b00, b01, idy1);
return Linear (b0, b1, idx1);
}
