/* This file is part of libgenerators, a library producing artificial
* and procedual content for the libdatatypes structures
* Copyright (C) 2004-2011 Niels Fröhling
*
* libgenerators.hpp: global header
* Copyright 2004-2011 Niels Fröhling
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef GENERATORS_H
#define GENERATORS_H
#pragma warning (disable : 4996)
#include <libdatatypes.hpp>
/*
* TODO:
* - ...
*
* CONCEPTS:
* ...
*/
/* ============================================================================
* basic datatype definitions
*/
class Generator {
public:
};
#if defined(DATATYPES_INCLUDE_0D)
class Generator0D : public Generator {
public:
virtual vec1D generate ( ) { abort(); return 0.0f; }
};
#endif
#if defined(DATATYPES_INCLUDE_1D)
class Generator1D : public Generator {
public:
virtual vec1D generate1D(const vec1D v) { abort(); }
virtual void generate (Buffer1D<vec1D>& fill, const vec1D norm) { abort(); }
};
#endif
#if defined(DATATYPES_INCLUDE_2D)
class Generator2D : public Generator {
public:
virtual vec2D<> generate2D(const vec2D<>& v) { abort(); }
virtual void generate (Buffer2D<vec2D<> >& fill, const vec1D norm) { abort(); }
};
#endif
#if defined(DATATYPES_INCLUDE_3D)
class Generator3D : public Generator {
public:
virtual vec3D<> generate3D(const vec3D<>& v) { abort(); }
//virtual void generate (Buffer3D<vec3D<> >& fill, const vec1D norm) { abort(); }
};
#endif
#if defined(DATATYPES_INCLUDE_4D)
class Generator4D : public Generator {
public:
virtual loc4D<> generate4D(const loc4D<>& v) { abort(); }
//virtual void generate (Buffer4D<loc4D<> >& fill, const vec1D norm) { abort(); }
};
#endif
#if defined(DATATYPES_INCLUDE_ND)
class GeneratorND : public Generator {
public:
//virtual vector3D generateND(const vectorND& v) { abort(); }
//virtual void generate (BufferND<vectorND>& fill, const vec1D norm) { abort(); }
};
#endif
#if defined(DATATYPES_INCLUDE_1D) && \
defined(DATATYPES_INCLUDE_2D) && \
defined(DATATYPES_INCLUDE_3D)
class GeneratorMD : public Generator1D,
public Generator2D,
public Generator3D {
public:
virtual vec1D generate1D(const vec1D v) { abort(); }
virtual Vector2D<> generate2D(const Vector2D<>& v) { abort(); }
virtual Vector3D<> generate3D(const Vector3D<>& v) { abort(); }
virtual void generate (Buffer1D< vec1D >& fill, const vec1D norm) { abort(); }
virtual void generate (Buffer2D<Vector2D<> >& fill, const vec1D norm) { abort(); }
//virtual void generate (Buffer3D<Vector3D<> >& fill, const vec1D norm) { abort(); }}
//virtual void generate (Buffer4D<Vector4D<> >& fill, const vec1D norm) { abort(); }}
//virtual void generate (BufferND<VectorND<> >& fill, const vec1D norm) { abort(); }}
};
#endif
/* ============================================================================
*/
#if !defined(GENERATORS_INCLUDE_0D) && \
!defined(GENERATORS_INCLUDE_1D) && \
!defined(GENERATORS_INCLUDE_2D) && \
!defined(GENERATORS_INCLUDE_3D) && \
!defined(GENERATORS_INCLUDE_4D) && \
!defined(GENERATORS_INCLUDE_ND) && \
!defined(GENERATORS_INCLUDE_MD)
#error
#define GENERATORS_INCLUDE_0D
#define GENERATORS_INCLUDE_1D
#define GENERATORS_INCLUDE_2D
#define GENERATORS_INCLUDE_3D
#define GENERATORS_INCLUDE_4D
#define GENERATORS_INCLUDE_ND
#define GENERATORS_INCLUDE_MD
#endif
#ifdef GENERATORS_INCLUDE_0D
#include "libgenerators-0.0.0/0D.hpp"
#endif
#ifdef GENERATORS_INCLUDE_1D
#include "libgenerators-0.0.0/1D.hpp"
#endif
#ifdef GENERATORS_INCLUDE_MD
#include "libgenerators-0.0.0/MD.hpp" // multi-dimensional
#endif
#ifdef GENERATORS_INCLUDE_ND
#include "libgenerators-0.0.0/ND.hpp" // n-dimensional
#endif
#ifdef GENERATORS_INCLUDE_2D
#include "libgenerators-0.0.0/2D.hpp"
#endif
#ifdef GENERATORS_INCLUDE_3D
#include "libgenerators-0.0.0/3D.hpp"
#endif
#ifdef GENERATORS_INCLUDE_4D
#include "libgenerators-0.0.0/4D.hpp"
#endif
#endif
