VRS - The Virtual Rendering System

version 3.3

tileablenoisetexturegl.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2004 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * 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 FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/
// $Id:  $
// $Date:  $
// $Revision:  $
// $Author:  $
//

#ifndef VRS_OPENGL_TILEABLENOISETEXTUREGL_H
#define VRS_OPENGL_TILEABLENOISETEXTUREGL_H

#include <vrs/config.h>
#include <vrs/vector.h>
#include <vrs/opengl/imagetexture1dgl.h>
#include <vrs/opengl/imagetexture2dgl.h>
#include <vrs/opengl/imagetexture3dgl.h>
#include <vrs/image/image.h>
#include <string>

namespace VRS {

class VRS_CORE_API TileableNoiseTexture1DGL : public ImageTexture1DGL {
public:
    TileableNoiseTexture1DGL(
        unsigned int size,
        double frequency = 1.0,
        double overlap = 0.5,
        const Vector& offset = Vector::origin,
        Image::LayerSequence layerSequence = Image::A,
        int dataType = Image::U8,
        TextureGL::WrapMode wrap = TextureGL::REPEAT,
        TextureGL::FilterMode minFilter = TextureGL::TRILINEAR,
        TextureGL::FilterMode magFilter = TextureGL::LINEAR
    );

    static SO<Image> createTileableNoise1D(
        unsigned int size = 128,
        double frequency = 1.0,
        double overlap = 0.5,
        const Vector& offset = Vector::origin,
        Image::LayerSequence layerSequence = Image::A,
        int dataType = Image::U8
    );

    VRS_TYPEINFO(TileableNoiseTexture1DGL, ImageTexture1DGL);
    VRS_SERIALIZABLE(TileableNoiseTexture1DGL);

protected:
    // for serialization only
    TileableNoiseTexture1DGL();
};

class VRS_CORE_API TileableNoiseTexture2DGL : public ImageTexture2DGL {
public:
    TileableNoiseTexture2DGL(
        unsigned int sizeS, unsigned int sizeT,
        double frequencyS = 1.0, double frequencyT = 1.0,
        double overlapS = 0.5, double overlapT = 0.5,
        const Vector& offset = Vector::origin,
        Image::LayerSequence layerSequence = Image::A,
        int dataType = Image::U8,
        TextureGL::WrapMode wrapS = TextureGL::REPEAT,
        TextureGL::WrapMode wrapT = TextureGL::REPEAT,
        TextureGL::FilterMode minFilter = TextureGL::TRILINEAR,
        TextureGL::FilterMode magFilter = TextureGL::LINEAR,
        GLfloat anisotropic = 1.0
    );

    static SO<Image> createTileableNoise2D(
        unsigned int sizeS = 128, unsigned int sizeT = 128,
        double frequencyS = 1.0, double frequencyT = 1.0,
        double overlapS = 0.5, double overlapT = 0.5,
        const Vector& offset = Vector::origin,
        Image::LayerSequence layerSequence = Image::A,
        int dataType = Image::U8
    );

    VRS_TYPEINFO(TileableNoiseTexture2DGL, ImageTexture2DGL);
    VRS_SERIALIZABLE(TileableNoiseTexture2DGL);

protected:
    // for serialization only
    TileableNoiseTexture2DGL();
};

class VRS_CORE_API TileableNoiseTexture3DGL : public ImageTexture3DGL {
public:

    TileableNoiseTexture3DGL(
        unsigned int sizeS, unsigned int sizeT, unsigned int sizeR, 
        double frequencyS = 1.0, double frequencyT = 1.0, double frequencyR = 1.0,
        double overlapS = 0.5, double overlapT = 0.5, double overlapR = 0.5,
        const Vector& offset = Vector::origin,
        Image::LayerSequence layerSequence = Image::A,
        int dataType = Image::U8,
        TextureGL::WrapMode wrapS = TextureGL::REPEAT,
        TextureGL::WrapMode wrapT = TextureGL::REPEAT,
        TextureGL::WrapMode wrapR = TextureGL::REPEAT,
        TextureGL::FilterMode minFilter = TextureGL::TRILINEAR,
        TextureGL::FilterMode magFilter = TextureGL::LINEAR,
        GLfloat anisotropic = 1.0,
        const std::string& filename = ""
    );

    TileableNoiseTexture3DGL(const std::string& filename);

    TileableNoiseTexture3DGL(const SO<Iterator<SO<Image> > >& noiseImages);

    static SO<Iterator<SO<Image> > > createTileableNoise3D(
        unsigned int sizeS = 128, unsigned int sizeT = 128, unsigned int sizeR = 128, 
        double frequencyS = 1.0, double frequencyT = 1.0, double frequencyR = 1.0,
        double overlapS = 0.5, double overlapT = 0.5, double overlapR = 0.5,
        const Vector& offset = Vector::origin,
        Image::LayerSequence layerSequence = Image::A,
        int dataType = Image::U8,
        const std::string& filename = ""
    );

    static SO<Iterator<SO<Image> > > createTileableNoise3D(const std::string& filename);

    static void writeNoise(const std::string& pathToFile, SO<Iterator<VRS::SO<VRS::Image> > > images);

    VRS_TYPEINFO(TileableNoiseTexture3DGL, ImageTexture3DGL);
    VRS_SERIALIZABLE(TileableNoiseTexture3DGL);

protected:
    // for serialization only
    TileableNoiseTexture3DGL();

private:
    static SO<Iterator<VRS::SO<VRS::Image> > > readNoise(const std::string& target);
};

} // namespace VRS

#endif // VRS_OPENGL_TILEABLENOISETEXTUREGL_H

---

Generated on Thu May 24 06:00:16 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact