ShLibWorley.hpp

// Sh: A GPU metaprogramming language.
//
// Copyright 2003-2005 Serious Hack Inc.
// 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
// MA  02110-1301, USA
#include "ShLib.hpp" // ShLibWorley needs to be included from within ShLib

#ifndef SHLIBWORLEY_HPP 
#define SHLIBWORLEY_HPP

#include <vector>
#include "ShAttrib.hpp"
#include "ShColor.hpp"

namespace SH {

// A Generator point represents the position of a generator relative
// to the cell origin of a lookup position. 
//
template<int D, typename T>
struct Generator {
  Generator() {}
  ShAttrib<D, SH_TEMP, T> pos; // position 
  ShAttrib<D, SH_TEMP, T> offset; // offset of the cell relative to lookup point's cell
  ShAttrib<D, SH_TEMP, T> cell; // integer cell (this should actually be typed T = int, but not possible yet) 
};

// Generator Factory 
// A Point Generator must implement a function that 
// sets a Generator array with P candidate generator points. 
template<int P, int D, typename T>
struct GeneratorFactory {
  static const int NUM_POINTS = P;
  virtual ~GeneratorFactory() {}
  virtual void operator()(const ShGeneric<D, T> &p, Generator<D, T> result[]) const = 0;
};

// Property Factory
// This takes a Generator and attaches N properties to it.
// The first property in the result is used to sort the generator points 
// (and so should probably be a distance metric).
template<int N, int D, typename T>
struct PropertyFactory {
  static const int NUM_PROPS = N;
  static const int DIM = D;
  typedef T PropType; 
  
  virtual ~PropertyFactory() {} 
  virtual ShGeneric<N, T> operator()(const ShGeneric<D, T> &p, const Generator<D, T> &g) const = 0; 
};

#ifndef WIN32

template<int K, int D, typename T>
ShGeneric<K, T> worley(const ShGeneric<D, T> &p, bool useTexture = true); 

template<int K, int L, int P, int D, typename T>
void worley(ShGeneric<K, T> result[], const ShGeneric<D, T> &p, 
            const GeneratorFactory<P, D, T> *genFactory,
            const PropertyFactory<L, D, T> *propFactory);

template<int K, int D, typename T>
ShProgram shWorley(bool useTexture);

template<int K, int N, int P, int D, typename T>
ShProgram shWorley(const GeneratorFactory<P, D, T> *genFactory,
                   const PropertyFactory<N, D, T> *propFactory);

#endif // WIN32

} // namespace SH

#include "ShLibWorleyImpl.hpp"

#endif // SHLIBWORLEY_HPP

---