WTURBULENCE.h

Go to the documentation of this file.

// This file is part of Wavelet Turbulence.
// 
// Wavelet Turbulence 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 3 of the License, or
// (at your option) any later version.
// 
// Wavelet Turbulence 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 Wavelet Turbulence.  If not, see <http://www.gnu.org/licenses/>.
// 
// Copyright 2008 Theodore Kim and Nils Thuerey
// 
// WTURBULENCE handling

#ifndef WTURBULENCE_H
#define WTURBULENCE_H

#include "VEC3.h"
using namespace BasicVector;
class SIMPLE_PARSER;

class WTURBULENCE  
{
    public:
        // both config files can be NULL, altCfg might override values from noiseCfg
        WTURBULENCE(int xResSm, int yResSm, int zResSm, int amplify, int noisetype);

        virtual ~WTURBULENCE();
        
        void setNoise(int type);
        void initBlenderRNA(float *strength);

        // step more readable version -- no rotation correction
        void stepTurbulenceReadable(float dt, float* xvel, float* yvel, float* zvel, unsigned char *obstacles);

        // step more complete version -- include rotation correction
        // and use OpenMP if available
        void stepTurbulenceFull(float dt, float* xvel, float* yvel, float* zvel, unsigned char *obstacles);
    
        // texcoord functions
        void advectTextureCoordinates(float dtOrg, float* xvel, float* yvel, float* zvel, float *tempBig1, float *tempBig2);
        void resetTextureCoordinates(float *_eigMin, float *_eigMax);

        void computeEnergy(float *energy, float* xvel, float* yvel, float* zvel, unsigned char *obstacles);

        // evaluate wavelet noise function
        Vec3 WVelocity(Vec3 p);
        Vec3 WVelocityWithJacobian(Vec3 p, float* xUnwarped, float* yUnwarped, float* zUnwarped);

        // access functions
        inline float* getDensityBig() { return _densityBig; }
        inline float* getArrayTcU() { return _tcU; }
        inline float* getArrayTcV() { return _tcV; }
        inline float* getArrayTcW() { return _tcW; }

        inline Vec3Int getResSm() { return _resSm; } // small resolution
        inline Vec3Int getResBig() { return _resBig; }
        inline int getOctaves() { return _octaves; }

        // is accessed on through rna gui
        float *_strength;

    // protected:
        // enlargement factor from original velocity field / simulation
        // _Big = _amplify * _Sm
        int _amplify;
        int _octaves;
        
        // noise settings
        float _cullingThreshold;
        // float _noiseStrength;
        // float _noiseSizeScale;
        // bool _uvwAdvection;
        // bool _uvwReset;
        // float _noiseTimeanimSpeed;
        // int _dumpInterval;
        // nt _noiseControlType;
        // debug, scale density for projections output images
        // float _outputScale;

        // noise resolution
        int _xResBig;
        int _yResBig;
        int _zResBig;
        Vec3Int _resBig;
        Vec3 _invResBig;
        int _totalCellsBig;
        int _slabSizeBig;
        // original / small resolution
        int _xResSm;
        int _yResSm;
        int _zResSm;
        Vec3Int _resSm;
        Vec3 _invResSm;
        int _totalCellsSm;
        int _slabSizeSm;

        float* _densityBig;
        float* _densityBigOld;

        // texture coordinates for noise
        float* _tcU;
        float* _tcV;
        float* _tcW;
        float* _tcTemp;

        // noise data
        float* _noiseTile;
        //float* _noiseTileExt;

        // step counter
        int _totalStepsBig;
        
        void computeEigenvalues(float *_eigMin, float *_eigMax);
        void decomposeEnergy(float *energy, float *_highFreqEnergy);
};

#endif // WTURBULENCE_H