Changeset 2805


Ignore:
Timestamp:
Mar 6, 2012, 12:28:02 PM (8 years ago)
Author:
ldelgass
Message:

Whitespace fixes

Location:
trunk/packages/vizservers/nanovis
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/nanovis/ParticleEmitter.cpp

    r2798 r2805  
    22#include "ParticleEmitter.h"
    33
    4 ParticleEmitter::ParticleEmitter()
    5 :
    6 _minLifeTime(30.0f), _maxLifeTime(100.0f),
    7 _maxPositionOffset(1, 1, 1),
    8 _minNumOfNewParticles(10), _maxNumOfNewParticles(20)
     4ParticleEmitter::ParticleEmitter() :
     5    _minLifeTime(30.0f), _maxLifeTime(100.0f),
     6    _maxPositionOffset(1, 1, 1),
     7    _minNumOfNewParticles(10), _maxNumOfNewParticles(20)
    98{
    109}
  • trunk/packages/vizservers/nanovis/ParticleEmitter.h

    r2798 r2805  
    55#include <string>
    66
    7 class ParticleEmitter {
    8 public :
    9         std::string _name;
    10         float3 _position;
     7class ParticleEmitter
     8{
     9public:
     10    std::string _name;
     11    float3 _position;
    1112
    12         float3 _oldPosition;
     13    float3 _oldPosition;
    1314
    14         float _minLifeTime;
    15         float _maxLifeTime;
     15    float _minLifeTime;
     16    float _maxLifeTime;
    1617       
    17         // [0..1] * _maxPositionOffset;
    18         float3 _maxPositionOffset;
     18    // [0..1] * _maxPositionOffset;
     19    float3 _maxPositionOffset;
    1920
    20         int _minNumOfNewParticles;
    21         int _maxNumOfNewParticles;
     21    int _minNumOfNewParticles;
     22    int _maxNumOfNewParticles;
    2223
    23         bool _enabled;
    24 public :
    25         ParticleEmitter();
     24    bool _enabled;
    2625
    27 public :
    28         void setName(const std::string& name);
    29         void setPosition(float x, float y, float z);
    30         void setMinMaxLifeTime(float minLifeTime, float maxLifeTime);
    31         void setMaxPositionOffset(float offsetX, float offsetY, float offsetZ);
    32         void setMinMaxNumOfNewParticles(int minNum, int maxNum);
     26    ParticleEmitter();
    3327
    34         void setVectorField();
    35         void setEnabled(bool enabled);
    36         bool isEnabled() const;
     28    void setName(const std::string& name);
     29    void setPosition(float x, float y, float z);
     30    void setMinMaxLifeTime(float minLifeTime, float maxLifeTime);
     31    void setMaxPositionOffset(float offsetX, float offsetY, float offsetZ);
     32    void setMinMaxNumOfNewParticles(int minNum, int maxNum);
     33
     34    void setVectorField();
     35    void setEnabled(bool enabled);
     36    bool isEnabled() const;
    3737};
    3838
    3939inline void ParticleEmitter::setName(const std::string& name)
    4040{
    41         _name = name;
     41    _name = name;
    4242}
    4343
    4444inline void ParticleEmitter::setPosition(float x, float y, float z)
    4545{
    46         _position.x = x;
    47         _position.y = y;
    48         _position.z = z;
     46    _position.x = x;
     47    _position.y = y;
     48    _position.z = z;
    4949}
    5050
    5151inline void ParticleEmitter::setMinMaxLifeTime(float minLifeTime, float maxLifeTime)
    5252{
    53         _minLifeTime = minLifeTime;
    54         _maxLifeTime = maxLifeTime;
     53    _minLifeTime = minLifeTime;
     54    _maxLifeTime = maxLifeTime;
    5555}
    5656
    5757inline void ParticleEmitter::setMaxPositionOffset(float offsetX, float offsetY, float offsetZ)
    5858{
    59         _maxPositionOffset.x = offsetX;
    60         _maxPositionOffset.y = offsetY;
    61         _maxPositionOffset.z = offsetZ;
     59    _maxPositionOffset.x = offsetX;
     60    _maxPositionOffset.y = offsetY;
     61    _maxPositionOffset.z = offsetZ;
    6262}
    6363
    6464inline void ParticleEmitter::setMinMaxNumOfNewParticles(int minNum, int maxNum)
    6565{
    66         _minNumOfNewParticles = minNum;
    67         _maxNumOfNewParticles = maxNum;
     66    _minNumOfNewParticles = minNum;
     67    _maxNumOfNewParticles = maxNum;
    6868}
    6969
    7070inline void ParticleEmitter::setEnabled(bool enabled)
    7171{
    72         _enabled = enabled;
     72    _enabled = enabled;
    7373}
    7474
    7575inline bool ParticleEmitter::isEnabled() const
    7676{
    77         return _enabled;
     77    return _enabled;
    7878}
  • trunk/packages/vizservers/nanovis/ParticleSystem.cpp

    r2803 r2805  
    3535//#define TEST
    3636// TEST
    37 extern void* LoadFlowDx(const char* fname, int& width, int& height, int&depth, float& min, float& max, float& nonzero_min,
    38                          float& axisScaleX, float& axisScaleY, float& axisScaleZ);
    39 extern void* LoadFlowRaw(const char* fname, int width, int height, int depth, float& min, float& max, float& nonzero_min,
    40                          float& axisScaleX, float& axisScaleY, float& axisScaleZ, int skipByte, bool bigEndian);
    41 extern void* LoadProcessedFlowRaw(const char* fname, int width, int height, int depth, float min, float max, float& axisScaleX, float& axisScaleY, float& axisScaleZ, int skipByte);
    42 extern void LoadProcessedFlowRaw(const char* fname, int width, int height, int depth, float* data);
     37extern void* LoadFlowDx(const char* fname, int& width, int& height, int&depth,
     38                        float& min, float& max, float& nonzero_min,
     39                        float& axisScaleX, float& axisScaleY, float& axisScaleZ);
     40extern void* LoadFlowRaw(const char* fname, int width, int height, int depth,
     41                         float& min, float& max, float& nonzero_min,
     42                         float& axisScaleX, float& axisScaleY, float& axisScaleZ,
     43                         int skipByte, bool bigEndian);
     44extern void* LoadProcessedFlowRaw(const char* fname, int width, int height, int depth,
     45                                  float min, float max,
     46                                  float& axisScaleX, float& axisScaleY, float& axisScaleZ, int skipByte);
     47extern void LoadProcessedFlowRaw(const char* fname, int width, int height, int depth,
     48                                 float* data);
     49
    4350inline float randomRange(float rangeMin, float rangeMax)
    4451{
    45         return ((float)rand() / RAND_MAX) * (rangeMax - rangeMin) + rangeMin ;
     52    return ((float)rand() / RAND_MAX) * (rangeMax - rangeMin) + rangeMin ;
    4653}
    4754
    4855inline int logd(int value)
    4956{
    50         int l;
    51         for (l = 0; value >> l; l++);
    52         return l - 1;
     57    int l;
     58    for (l = 0; value >> l; l++);
     59    return l - 1;
    5360}
    5461
    5562inline void swap(int& x, int& y)
    5663{
    57         if (x != y)
    58         {
    59                 x ^= y;
    60                 y ^= x;
    61                 x ^= y;
     64    if (x != y) {
     65        x ^= y;
     66        y ^= x;
     67        x ^= y;
     68    }
     69}
     70
     71void* ParticleSystem::dataLoadMain(void* data)
     72{
     73       
     74    ParticleSystem* particleSystem = (ParticleSystem*) data;
     75    CircularFifo<float*, 10>& queue = particleSystem->_queue;
     76       
     77    // TBD..
     78    //float min = particleSystem->_time_series_vel_mag_min;
     79    //float max = particleSystem->_time_series_vel_mag_max;
     80
     81    int startIndex = particleSystem->_flowFileStartIndex;
     82    int endIndex = particleSystem->_flowFileEndIndex;
     83
     84    int curIndex = startIndex;
     85    float flowWidth = particleSystem->_flowWidth;
     86    float flowHeight = particleSystem->_flowHeight;
     87    float flowDepth = particleSystem->_flowDepth;
     88       
     89    const char* fileNameFormat = particleSystem->_fileNameFormat.c_str();
     90    char buff[256];
     91
     92    bool done = false;
     93    while (!done) {
     94        if (curIndex > endIndex) {
     95            curIndex = startIndex;
     96        }
     97
     98        if (!queue.isFull()) {
     99            int tail = queue.tailIndex();
     100            if (tail != -1) {
     101                sprintf(buff, fileNameFormat, curIndex);
     102                //std::string path = vrFilePath::getInstance()->getPath(buff);
     103                float t = clock() /(float) CLOCKS_PER_SEC;
     104                LoadProcessedFlowRaw(buff, flowWidth, flowHeight, flowDepth, queue.array[tail]);
     105                float ti = clock() / (float) CLOCKS_PER_SEC;
     106                printf("%f\n",ti - t);
     107                queue.push();
     108                TRACE("%d loaded\n", curIndex);
     109                ++curIndex;
     110            }
    62111        }
    63 }
    64 
    65 void* ParticleSystem::dataLoadMain(void* data)
    66 {
    67        
    68         ParticleSystem* particleSystem = (ParticleSystem*) data;
    69         CircularFifo<float*, 10>& queue = particleSystem->_queue;
    70        
    71         // TBD..
    72         //float min = particleSystem->_time_series_vel_mag_min;
    73         //float max = particleSystem->_time_series_vel_mag_max;
    74 
    75         int startIndex = particleSystem->_flowFileStartIndex;
    76         int endIndex = particleSystem->_flowFileEndIndex;
    77 
    78         int curIndex = startIndex;
    79         float flowWidth = particleSystem->_flowWidth;
    80         float flowHeight = particleSystem->_flowHeight;
    81         float flowDepth = particleSystem->_flowDepth;
    82        
    83         const char* fileNameFormat = particleSystem->_fileNameFormat.c_str();
    84         char buff[256];
    85 
    86         bool done = false;
    87         while (!done)
    88         {
    89                 if (curIndex > endIndex)
    90                 {
    91                         curIndex = startIndex;
    92                 }
    93 
    94                 if (!queue.isFull())
    95                 {
    96                         int tail = queue.tailIndex();
    97                         if (tail != -1)
    98                         {
    99                                 sprintf(buff, fileNameFormat, curIndex);
    100                                 //std::string path = vrFilePath::getInstance()->getPath(buff);
    101                                 float t = clock() /(float) CLOCKS_PER_SEC;
    102                                 LoadProcessedFlowRaw(buff, flowWidth, flowHeight, flowDepth, queue.array[tail]);
    103                                 float ti = clock() / (float) CLOCKS_PER_SEC;
    104                                 printf("%f\n",ti - t);
    105                                 queue.push();
    106                                 TRACE("%d loaded\n", curIndex);
    107                                 ++curIndex;
    108                         }
    109                 }
    110                 else
    111                 {
    112                         //TRACE("full\n");
    113                 }
    114         }
    115 
    116         return 0;
    117 }
    118 
     112
     113    return 0;
     114}
    119115
    120116CGcontext ParticleSystem::_context = 0;
     
    124120void MakeSphereTexture()
    125121{
    126 
    127122    const int DIM = 128;
    128123    const int DIM2 = 63;
     
    132127    glBindTexture(GL_TEXTURE_2D, SpotTexID);
    133128
    134         float col[4] = {1.f, 1.f, 1.f, 1.f};
    135         glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, col);
    136         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
     129    float col[4] = {1.f, 1.f, 1.f, 1.f};
     130    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, col);
     131    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    137132
    138133
     
    142137    light.normalize();
    143138
    144     for(int y=0; y<DIM; y++) {
    145         for(int x=0; x<DIM; x++) {
     139    for (int y = 0; y < DIM; y++) {
     140        for (int x = 0; x < DIM; x++) {
    146141            // Clamping the edges to zero allows Nvidia's blend optimizations to do their thing.
    147             if(x==0 || x==DIM-1 || y==0 || y==DIM-1)
     142            if (x==0 || x==DIM-1 || y==0 || y==DIM-1) {
    148143                img[y*DIM+x] = 0;
    149             else {
     144            } else {
    150145                vrVector3f p(x, y, 0);
    151146                p = p - vrVector3f(DIM2, DIM2, 0);
     
    153148                float z = sqrt(DIM2*DIM2 - len*len);
    154149                p.z = z;
    155                 if(len >= DIM2) {
     150                if (len >= DIM2) {
    156151                    img[y*DIM+x] = 0.0;
    157152                    continue;
     
    172167    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    173168
    174 
    175169    gluBuild2DMipmaps(GL_TEXTURE_2D, GL_ALPHA16, DIM, DIM, GL_ALPHA, GL_FLOAT, img);
    176170}
     
    178172//extern void algorithm_test(vrVector4f* data, int flowWidth, int flowHeight, int flowDepth);
    179173//extern std::vector<vrVector3f>* find_critical_points(vrVector4f* data, int flowWidth, int flowHeight, int flowDepth);
    180 ParticleSystem::ParticleSystem(int width, int height, const std::string& fileName, int fieldWidth, int fieldHeight, int fieldDepth,
    181                                                            bool timeVaryingData, int flowFileStartIndex, int flowFileEndIndex)
    182 : _width(width), _height(height)
    183 {
    184         ////////////////////////////////
    185         // TIME-VARYING SERIES
    186         _isTimeVaryingField = timeVaryingData;
    187         _flowFileStartIndex = flowFileStartIndex;
    188         _flowFileEndIndex = flowFileEndIndex;
    189         _userDefinedParticleMaxCount = width * height;
    190 
    191 
    192         _skipByte = 0;
    193 
    194         _screenWidth = _screenHeight = 1;
    195         _fov = 60.0f;
    196 
    197         _particleMaxCount = _width * _height;
    198 
    199         _pointSize = 10.0f;
    200         _camx = 0.0f;
    201         _camy = 0.0f;
    202         _camz = 0.0f;
    203 
    204         _scalex = _scaley = _scalez = 1.0f;
    205         _currentSortIndex = 0;
    206         _destSortIndex = 1;
    207 
    208         _currentPosIndex = 0;
    209         _destPosIndex = 1;
    210 
    211         _currentSortPass = 0;
    212         // TBD
    213         //_sortPassesPerFrame = 5;
    214         _sortPassesPerFrame = 4;
    215         _maxSortPasses = 0;
    216 
    217         _sortBegin = 0;
    218         _sortEnd = _sortPassesPerFrame;
    219         _currentTime = 0;
    220         _sortEnabled = false;
    221         _glypEnabled = false;
    222         _advectionEnabled = false;
    223         _streamlineEnabled = false;
    224         _particles = new Particle[_particleMaxCount];
    225         memset(_particles, 0, sizeof(Particle) * _particleMaxCount);
    226 
    227         _colorBuffer = new color4[_particleMaxCount];
    228         memset(_colorBuffer, 0, sizeof(color4) * _particleMaxCount);
    229 
    230         _positionBuffer = new float3[_particleMaxCount];
    231         _vertices = new RenderVertexArray(_particleMaxCount, 3, GL_FLOAT);
    232 
    233         srand(time(0));
    234 
    235         /*
    236         // TBD..
    237         glGenBuffersARB(1, &_colorBufferID);
    238         glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
    239         glBufferDataARB(GL_ARRAY_BUFFER, _width * _height * 4, _colorBuffer, GL_STREAM_DRAW_ARB); // undefined data
    240         glBindBufferARB(GL_ARRAY_BUFFER, 0);
    241         */
    242        
    243         _flowWidth = fieldWidth;
    244         _flowHeight = fieldHeight;
    245         _flowDepth = fieldDepth;
    246 
    247         float min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ;
    248         int index = fileName.rfind('.');
    249         std::string ext = fileName.substr(index + 1, fileName.size() - (index + 1));
    250         float* data = 0;
    251 
    252        
    253         if (this->isTimeVaryingField())
    254         {
    255                 axisScaleX = _flowWidth;
    256                 axisScaleY = _flowHeight;
    257                 axisScaleZ = _flowDepth;
    258                 _fileNameFormat = fileName;
    259                 for (int i = 0; i < CircularFifo<float*, 10>::Capacity; ++i)
    260                 {
    261                         _queue.array[i] = new float[_flowWidth * _flowHeight * _flowDepth * 4];
    262                 }
    263                
    264                
    265                 // INSOO
    266                 // TBD
    267                 min = 0;
    268                 max = 234.99;
    269         }
    270         else
    271         {
    272                 if (ext == "dx")
    273                 {
    274                         data = (float*) LoadFlowDx(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ);
    275                 }
    276                 else if (ext == "raw")
    277                 {
    278                         data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 0, false);
    279                         //data = (float*) LoadProcessedFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, axisScaleX, axisScaleY, axisScaleZ);
    280                 }
    281                 /*
    282                 else if (ext == "raws")
    283                 {
    284                         data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 5 * sizeof(int), true);
    285                 }
    286                 else if (ext == "data")
    287                 {
    288                         data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 0, true);
    289                 }
    290                 */
    291        
    292 
    293                 //_criticalPoints = find_critical_points((vrVector4f*) data, _flowWidth,  _flowHeight,  _flowDepth);
    294                 //algorithm_test((vrVector4f*) data,  _flowWidth,  _flowHeight,  _flowDepth);
    295         }
    296 
    297         _scalex = 1;
    298         _scaley = axisScaleY / axisScaleX;
    299         _scalez = axisScaleZ / axisScaleX;
    300         _maxVelocityScale = max;
    301 
    302         if (!this->isTimeVaryingField())
    303         {
    304                 vrTexture3D* flow = new vrTexture3D();
    305                 flow->setMinFilter(TF_LINEAR);
    306                 flow->setMagFilter(TF_LINEAR);
    307                 flow->setPixels(CF_RGBA, DT_FLOAT, _flowWidth, _flowHeight, _flowDepth, data);
    308                 this->_curVectorFieldID = flow->getGraphicsObjectID();
    309                 _vectorFieldIDs.push_back(_curVectorFieldID);
    310         }
    311         else
    312         {
    313                 for (int i = 0; i < 3; ++i)
    314                 {
    315                         vrTexture3D* flow = new vrTexture3D();
    316                         flow->setMinFilter(TF_LINEAR);
    317                         flow->setMagFilter(TF_LINEAR);
    318                         flow->setPixels(CF_RGBA, DT_FLOAT, _flowWidth, _flowHeight, _flowDepth, data);
    319                         _vectorFields.push_back(flow);
    320                         _vectorFieldIDs.push_back(flow->getGraphicsObjectID());
    321                 }
    322 
    323                 this->_curVectorFieldID = _vectorFieldIDs[0];
    324         }
    325 
    326         _arrows = new vrTexture2D();
    327         _arrows->setWrapS(TW_MIRROR);
    328         _arrows->setWrapT(TW_MIRROR);
     174ParticleSystem::ParticleSystem(int width, int height,
     175                               const std::string& fileName,
     176                               int fieldWidth, int fieldHeight, int fieldDepth,
     177                               bool timeVaryingData,
     178                               int flowFileStartIndex, int flowFileEndIndex) :
     179  _width(width), _height(height)
     180{
     181    ////////////////////////////////
     182    // TIME-VARYING SERIES
     183    _isTimeVaryingField = timeVaryingData;
     184    _flowFileStartIndex = flowFileStartIndex;
     185    _flowFileEndIndex = flowFileEndIndex;
     186    _userDefinedParticleMaxCount = width * height;
     187
     188    _skipByte = 0;
     189
     190    _screenWidth = _screenHeight = 1;
     191    _fov = 60.0f;
     192
     193    _particleMaxCount = _width * _height;
     194
     195    _pointSize = 10.0f;
     196    _camx = 0.0f;
     197    _camy = 0.0f;
     198    _camz = 0.0f;
     199
     200    _scalex = _scaley = _scalez = 1.0f;
     201    _currentSortIndex = 0;
     202    _destSortIndex = 1;
     203
     204    _currentPosIndex = 0;
     205    _destPosIndex = 1;
     206
     207    _currentSortPass = 0;
     208    // TBD
     209    //_sortPassesPerFrame = 5;
     210    _sortPassesPerFrame = 4;
     211    _maxSortPasses = 0;
     212
     213    _sortBegin = 0;
     214    _sortEnd = _sortPassesPerFrame;
     215    _currentTime = 0;
     216    _sortEnabled = false;
     217    _glypEnabled = false;
     218    _advectionEnabled = false;
     219    _streamlineEnabled = false;
     220    _particles = new Particle[_particleMaxCount];
     221    memset(_particles, 0, sizeof(Particle) * _particleMaxCount);
     222
     223    _colorBuffer = new color4[_particleMaxCount];
     224    memset(_colorBuffer, 0, sizeof(color4) * _particleMaxCount);
     225
     226    _positionBuffer = new float3[_particleMaxCount];
     227    _vertices = new RenderVertexArray(_particleMaxCount, 3, GL_FLOAT);
     228
     229    srand(time(0));
     230
     231    /*
     232    // TBD..
     233    glGenBuffersARB(1, &_colorBufferID);
     234    glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
     235    glBufferDataARB(GL_ARRAY_BUFFER, _width * _height * 4, _colorBuffer, GL_STREAM_DRAW_ARB); // undefined data
     236    glBindBufferARB(GL_ARRAY_BUFFER, 0);
     237    */
     238
     239    _flowWidth = fieldWidth;
     240    _flowHeight = fieldHeight;
     241    _flowDepth = fieldDepth;
     242
     243    float min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ;
     244    int index = fileName.rfind('.');
     245    std::string ext = fileName.substr(index + 1, fileName.size() - (index + 1));
     246    float* data = 0;
     247
     248
     249    if (this->isTimeVaryingField()) {
     250        axisScaleX = _flowWidth;
     251        axisScaleY = _flowHeight;
     252        axisScaleZ = _flowDepth;
     253        _fileNameFormat = fileName;
     254        for (int i = 0; i < CircularFifo<float*, 10>::Capacity; ++i) {
     255            _queue.array[i] = new float[_flowWidth * _flowHeight * _flowDepth * 4];
     256        }
     257
     258        // INSOO
     259        // TBD
     260        min = 0;
     261        max = 234.99;
     262    } else {
     263        if (ext == "dx") {
     264            data = (float*) LoadFlowDx(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ);
     265        } else if (ext == "raw") {
     266            data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 0, false);
     267            //data = (float*) LoadProcessedFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, axisScaleX, axisScaleY, axisScaleZ);
     268#ifdef notdef
     269        } else if (ext == "raws") {
     270            data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 5 * sizeof(int), true);
     271        } else if (ext == "data") {
     272            data = (float*) LoadFlowRaw(fileName.c_str(), _flowWidth, _flowHeight, _flowDepth, min, max, nonzero_min, axisScaleX, axisScaleY, axisScaleZ, 0, true);
     273        }
     274#endif 
     275        //_criticalPoints = find_critical_points((vrVector4f*) data, _flowWidth,  _flowHeight,  _flowDepth);
     276        //algorithm_test((vrVector4f*) data,  _flowWidth,  _flowHeight,  _flowDepth);
     277    }
     278
     279    _scalex = 1;
     280    _scaley = axisScaleY / axisScaleX;
     281    _scalez = axisScaleZ / axisScaleX;
     282    _maxVelocityScale = max;
     283
     284    if (!this->isTimeVaryingField()) {
     285        vrTexture3D* flow = new vrTexture3D();
     286        flow->setMinFilter(TF_LINEAR);
     287        flow->setMagFilter(TF_LINEAR);
     288        flow->setPixels(CF_RGBA, DT_FLOAT, _flowWidth, _flowHeight, _flowDepth, data);
     289        this->_curVectorFieldID = flow->getGraphicsObjectID();
     290        _vectorFieldIDs.push_back(_curVectorFieldID);
     291    } else {
     292        for (int i = 0; i < 3; ++i) {
     293            vrTexture3D* flow = new vrTexture3D();
     294            flow->setMinFilter(TF_LINEAR);
     295            flow->setMagFilter(TF_LINEAR);
     296            flow->setPixels(CF_RGBA, DT_FLOAT, _flowWidth, _flowHeight, _flowDepth, data);
     297            _vectorFields.push_back(flow);
     298            _vectorFieldIDs.push_back(flow->getGraphicsObjectID());
     299        }
     300        this->_curVectorFieldID = _vectorFieldIDs[0];
     301    }
     302
     303    _arrows = new vrTexture2D();
     304    _arrows->setWrapS(TW_MIRROR);
     305    _arrows->setWrapT(TW_MIRROR);
    329306
    330307#ifdef _WIN32
    331308#ifndef USE_RGBA_ARROW
    332         std::string path = vrFilePath::getInstance()->getPath("arrows.bmp");
    333         AUX_RGBImageRec *pTextureImage = auxDIBImageLoad(path.c_str());
    334         _arrows->setPixels(CF_RGB, DT_UBYTE, pTextureImage->sizeX, pTextureImage->sizeY, (void*) pTextureImage->data);
     309    std::string path = vrFilePath::getInstance()->getPath("arrows.bmp");
     310    AUX_RGBImageRec *pTextureImage = auxDIBImageLoad(path.c_str());
     311    _arrows->setPixels(CF_RGB, DT_UBYTE, pTextureImage->sizeX, pTextureImage->sizeY, (void*) pTextureImage->data);
    335312#else
    336         std::string path = vrFilePath::getInstance()->getPath("arrows_red_bg.bmp");
    337         AUX_RGBImageRec *pTextureImage = auxDIBImageLoad(path.c_str());
    338         unsigned char* pixels = new unsigned char [pTextureImage->sizeX * pTextureImage->sizeY * sizeof(unsigned char) * 4];
    339         unsigned char* srcPixels = pTextureImage->data;
    340         unsigned char* dstPixels = pixels;
    341         for (int i = 0; i < pTextureImage->sizeX * pTextureImage->sizeY; ++i)
    342         {
    343                 *dstPixels = *srcPixels; ++srcPixels;
    344                 *(dstPixels + 1) = *srcPixels; ++srcPixels;
    345                 *(dstPixels + 2) = *srcPixels; ++srcPixels;
    346 
    347                 if ((*dstPixels > 127) && (*(dstPixels + 1) < 127) && (*(dstPixels + 2) < 127))
    348                 {
    349                         *(dstPixels + 3) = 0;
    350                 }
    351                 else
    352                 {
    353                         *(dstPixels + 3) = 255;
    354                 }
    355 
    356                 dstPixels += 4;
    357         }
    358         _arrows->setPixels(CF_RGBA, DT_UBYTE, pTextureImage->sizeX, pTextureImage->sizeY, (void*) pixels);
     313    std::string path = vrFilePath::getInstance()->getPath("arrows_red_bg.bmp");
     314    AUX_RGBImageRec *pTextureImage = auxDIBImageLoad(path.c_str());
     315    unsigned char* pixels = new unsigned char [pTextureImage->sizeX * pTextureImage->sizeY * sizeof(unsigned char) * 4];
     316    unsigned char* srcPixels = pTextureImage->data;
     317    unsigned char* dstPixels = pixels;
     318    for (int i = 0; i < pTextureImage->sizeX * pTextureImage->sizeY; ++i) {
     319        *dstPixels = *srcPixels; ++srcPixels;
     320        *(dstPixels + 1) = *srcPixels; ++srcPixels;
     321        *(dstPixels + 2) = *srcPixels; ++srcPixels;
     322
     323        if ((*dstPixels > 127) && (*(dstPixels + 1) < 127) && (*(dstPixels + 2) < 127)) {
     324            *(dstPixels + 3) = 0;
     325        } else {
     326            *(dstPixels + 3) = 255;
     327        }
     328
     329        dstPixels += 4;
     330    }
     331    _arrows->setPixels(CF_RGBA, DT_UBYTE, pTextureImage->sizeX, pTextureImage->sizeY, (void*) pixels);
    359332#endif
    360333
    361334#else
    362335#ifndef USE_RGBA_ARROW
    363         IplImage* pTextureImage = cvLoadImage("arrows_flip2.png");
    364         _arrows->setPixels(CF_RGB, DT_UBYTE, pTextureImage->width, pTextureImage->height, (void*) pTextureImage->imageData);
     336    IplImage* pTextureImage = cvLoadImage("arrows_flip2.png");
     337    _arrows->setPixels(CF_RGB, DT_UBYTE, pTextureImage->width, pTextureImage->height, (void*) pTextureImage->imageData);
    365338#else
    366         // TBD..
    367         /*
    368         std::string path = vrFilePath::getInstance()->getPath("arrows_red_bg.bmp");
    369         AUX_RGBImageRec *pTextureImage = auxDIBImageLoad(path.c_str());
    370         unsigned char* pixels = new unsigned char [pTextureImage->sizeX * pTextureImage->sizeY * sizeof(unsigned char) * 4];
    371         unsigned char* srcPixels = pTextureImage->data;
    372         unsigned char* dstPixels = pixels;
    373         for (int i = 0; i < pTextureImage->sizeX * pTextureImage->sizeY; ++i)
    374         {
    375                 *dstPixels = *srcPixels; ++srcPixels;
    376                 *(dstPixels + 1) = *srcPixels; ++srcPixels;
    377                 *(dstPixels + 2) = *srcPixels; ++srcPixels;
    378 
    379                 if ((*dstPixels > 127) && (*(dstPixels + 1) < 127) && (*(dstPixels + 2) < 127))
    380                 {
    381                         *(dstPixels + 3) = 0;
    382                 }
    383                 else
    384                 {
    385                         *(dstPixels + 3) = 255;
    386                 }
    387 
    388                 dstPixels += 4;
    389         }
    390 
    391         _arrows->setPixels(CF_RGBA, DT_UBYTE, pTextureImage->sizeX, pTextureImage->sizeY, (void*) pixels);
    392         */
     339
     340#ifdef notdef
     341    // TBD..
     342      std::string path = vrFilePath::getInstance()->getPath("arrows_red_bg.bmp");
     343      AUX_RGBImageRec *pTextureImage = auxDIBImageLoad(path.c_str());
     344      unsigned char* pixels = new unsigned char [pTextureImage->sizeX * pTextureImage->sizeY * sizeof(unsigned char) * 4];
     345      unsigned char* srcPixels = pTextureImage->data;
     346      unsigned char* dstPixels = pixels;
     347      for (int i = 0; i < pTextureImage->sizeX * pTextureImage->sizeY; ++i) {
     348          *dstPixels = *srcPixels; ++srcPixels;
     349          *(dstPixels + 1) = *srcPixels; ++srcPixels;
     350          *(dstPixels + 2) = *srcPixels; ++srcPixels;
     351
     352          if ((*dstPixels > 127) && (*(dstPixels + 1) < 127) && (*(dstPixels + 2) < 127)) {
     353              *(dstPixels + 3) = 0;
     354          } else {
     355              *(dstPixels + 3) = 255;
     356          }
     357
     358          dstPixels += 4;
     359      }
     360
     361      _arrows->setPixels(CF_RGBA, DT_UBYTE, pTextureImage->sizeX, pTextureImage->sizeY, (void*) pixels);
     362#endif
    393363
    394364#endif // USE_RGBA_ARROW
     
    396366
    397367#ifdef TEST
    398         MakeSphereTexture();
     368    MakeSphereTexture();
    399369#endif
    400        
    401         glGenBuffersARB(1, &_particleInfoBufferID);
    402         glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
    403         glBufferDataARB(GL_ARRAY_BUFFER_ARB, _particleMaxCount * 4 * sizeof(float), 0, GL_DYNAMIC_DRAW);
    404         glVertexAttribPointerARB(8, 4, GL_FLOAT, GL_FALSE, 0, 0);  // 8 = texcoord0
    405         glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
    406        
    407        
    408         // TBD..
    409         initStreamlines(_width, _height);
    410         initInitPosTex();
    411 
    412         initShaders();
    413         createRenderTargets();
    414         createSortRenderTargets();
    415         createStreamlineRenderTargets();
    416 
    417         if (this->isTimeVaryingField())
    418         {
    419                 pthread_t _threads;
    420                 pthread_attr_t pthread_custom_attr;
    421                 pthread_attr_init(&pthread_custom_attr);
    422                 pthread_create(&_threads, &pthread_custom_attr, dataLoadMain, (void *) this);
    423         }
     370
     371    glGenBuffersARB(1, &_particleInfoBufferID);
     372    glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
     373    glBufferDataARB(GL_ARRAY_BUFFER_ARB, _particleMaxCount * 4 * sizeof(float), 0, GL_DYNAMIC_DRAW);
     374    glVertexAttribPointerARB(8, 4, GL_FLOAT, GL_FALSE, 0, 0);  // 8 = texcoord0
     375    glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
     376
     377    // TBD..
     378    initStreamlines(_width, _height);
     379    initInitPosTex();
     380
     381    initShaders();
     382    createRenderTargets();
     383    createSortRenderTargets();
     384    createStreamlineRenderTargets();
     385
     386    if (this->isTimeVaryingField()) {
     387        pthread_t _threads;
     388        pthread_attr_t pthread_custom_attr;
     389        pthread_attr_init(&pthread_custom_attr);
     390        pthread_create(&_threads, &pthread_custom_attr, dataLoadMain, (void *) this);
     391    }
    424392}
    425393
    426394void ParticleSystem::initInitPosTex()
    427395{
    428         glGenFramebuffersEXT(1, &_initPos_fbo);
     396    glGenFramebuffersEXT(1, &_initPos_fbo);
    429397    glGenTextures(1, &_initPosTex);
    430398
    431399    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _initPos_fbo);
    432    
    433         glViewport(0, 0, _width, _height);
    434         glMatrixMode(GL_PROJECTION);
    435         glLoadIdentity();
    436         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    437         glMatrixMode(GL_MODELVIEW);
    438         glLoadIdentity();
     400
     401    glViewport(0, 0, _width, _height);
     402    glMatrixMode(GL_PROJECTION);
     403    glLoadIdentity();
     404    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     405    glMatrixMode(GL_MODELVIEW);
     406    glLoadIdentity();
    439407
    440408    glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
    441409    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    442         glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    443         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    444         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     410    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     411    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     412    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    445413    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
    446                         _width, _height, 0, GL_RGB, GL_FLOAT, NULL);
    447         glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
     414                 _width, _height, 0, GL_RGB, GL_FLOAT, NULL);
     415    glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
    448416
    449417    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
    450                 GL_TEXTURE_RECTANGLE_NV, _initPosTex, 0);
    451        
    452  
     418                              GL_TEXTURE_RECTANGLE_NV, _initPosTex, 0);
     419
    453420    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    454421}
     
    456423void ParticleSystem::initStreamlines(int width, int height)
    457424{
    458         _atlas_x = 32;
    459         _atlas_y = 32;
    460 
    461         _atlasWidth = width * _atlas_x;
    462         _atlasHeight = height * _atlas_y;
    463         _maxAtlasCount = _atlas_x * _atlas_y;
    464 
    465         _stepSizeStreamline = 1;
    466         _curStepCount = 0;
    467         _particleCount = width * height;
    468 
    469         _currentStreamlineOffset = 0;
    470         _currentStreamlineIndex = 0;
    471         _streamVertices = new RenderVertexArray(_atlasWidth*_atlasHeight * 2, 3, GL_FLOAT);
    472 
    473         _maxIndexBufferSize = _width * _height * _atlas_x * _atlas_y;
    474         _indexBuffer = new unsigned int[_maxIndexBufferSize * 2];
    475         unsigned int* pindex = _indexBuffer;
    476         int ax, ay, old_ax = 0, old_ay = 0;
    477         for (unsigned int i = 1; i < _maxAtlasCount; ++i)
    478         {
    479                 ax = (i % _atlas_x) * width;   
    480                 ay = (i / _atlas_x) * height;
    481                
    482                 for (int y = 0; y < height ; ++y)
    483                         for (int x = 0; x < width; ++x)
    484                         {
    485                                 *pindex = (old_ay + y) * _atlasWidth + old_ax + x; ++pindex;
    486                                 *pindex = (ay + y) * _atlasWidth + ax + x; ++pindex;
    487                         }
    488 
    489                 old_ax = ax;
    490                 old_ay = ay;
    491         }
     425    _atlas_x = 32;
     426    _atlas_y = 32;
     427
     428    _atlasWidth = width * _atlas_x;
     429    _atlasHeight = height * _atlas_y;
     430    _maxAtlasCount = _atlas_x * _atlas_y;
     431
     432    _stepSizeStreamline = 1;
     433    _curStepCount = 0;
     434    _particleCount = width * height;
     435
     436    _currentStreamlineOffset = 0;
     437    _currentStreamlineIndex = 0;
     438    _streamVertices = new RenderVertexArray(_atlasWidth*_atlasHeight * 2, 3, GL_FLOAT);
     439
     440    _maxIndexBufferSize = _width * _height * _atlas_x * _atlas_y;
     441    _indexBuffer = new unsigned int[_maxIndexBufferSize * 2];
     442    unsigned int* pindex = _indexBuffer;
     443    int ax, ay, old_ax = 0, old_ay = 0;
     444    for (unsigned int i = 1; i < _maxAtlasCount; ++i) {
     445        ax = (i % _atlas_x) * width;
     446        ay = (i / _atlas_x) * height;
     447
     448        for (int y = 0; y < height ; ++y) {
     449            for (int x = 0; x < width; ++x) {
     450                *pindex = (old_ay + y) * _atlasWidth + old_ax + x; ++pindex;
     451                *pindex = (ay + y) * _atlasWidth + ax + x; ++pindex;
     452            }
     453        }
     454
     455        old_ax = ax;
     456        old_ay = ay;
     457    }
    492458}
    493459
    494460void ParticleSystem::callbackForCgError()
    495461{
    496         CGerror lastError = cgGetError();
     462    CGerror lastError = cgGetError();
    497463    if(lastError) {
    498464        const char *listing = cgGetLastListing(_context);
     
    511477void ParticleSystem::initShaders()
    512478{
    513         // TBD...
    514         _context = cgCreateContext();
    515         cgSetErrorCallback(callbackForCgError);
    516 
    517         std::string path = vrFilePath::getInstance()->getPath("distance.cg");
    518         _distanceInitFP = 
    519                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    520                                                         CG_PROFILE_FP30, "initSortIndex", NULL);
    521         cgGLLoadProgram(_distanceInitFP);
    522 
    523         _distanceSortFP =
    524                 cgCreateProgramFromFile(_context, CG_SOURCE,  path.c_str(),
    525                                                         CG_PROFILE_FP30, "computeDistance", NULL);
    526         _viewPosParam = cgGetNamedParameter(_distanceSortFP, "viewerPosition");
    527         cgGLLoadProgram(_distanceSortFP);
    528 
    529         _distanceSortLookupFP =
    530                 cgCreateProgramFromFile(_context, CG_SOURCE,  path.c_str(),
    531                                                         CG_PROFILE_FP30, "lookupPosition", NULL);
    532         cgGLLoadProgram(_distanceSortLookupFP);
    533 
    534         path = vrFilePath::getInstance()->getPath("mergesort.cg");
    535         _sortRecursionFP =
    536                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    537                                                         CG_PROFILE_FP30, "mergeSortRecursion", NULL);
    538         cgGLLoadProgram(_sortRecursionFP);
    539 
    540         _srSizeParam = cgGetNamedParameter(_sortRecursionFP, "_Size");
    541         _srStepParam = cgGetNamedParameter(_sortRecursionFP, "_Step");
    542         _srCountParam = cgGetNamedParameter(_sortRecursionFP, "_Count");
    543 
    544         _sortEndFP =
    545                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    546                                                         CG_PROFILE_FP30, "mergeSortEnd", NULL);
    547         cgGLLoadProgram(_sortEndFP);
    548 
    549         _seSizeParam = cgGetNamedParameter(_sortEndFP, "size");
    550         _seStepParam = cgGetNamedParameter(_sortEndFP, "step");
    551 
    552         path = vrFilePath::getInstance()->getPath("passthrough.cg");
    553         _passthroughFP =
    554                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    555                                                         CG_PROFILE_FP30, "main", NULL);
    556         cgGLLoadProgram(_passthroughFP);
     479    // TBD...
     480    _context = cgCreateContext();
     481    cgSetErrorCallback(callbackForCgError);
     482
     483    std::string path = vrFilePath::getInstance()->getPath("distance.cg");
     484    _distanceInitFP = 
     485        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     486                                CG_PROFILE_FP30, "initSortIndex", NULL);
     487    cgGLLoadProgram(_distanceInitFP);
     488
     489    _distanceSortFP =
     490        cgCreateProgramFromFile(_context, CG_SOURCE,  path.c_str(),
     491                                CG_PROFILE_FP30, "computeDistance", NULL);
     492    _viewPosParam = cgGetNamedParameter(_distanceSortFP, "viewerPosition");
     493    cgGLLoadProgram(_distanceSortFP);
     494
     495    _distanceSortLookupFP =
     496        cgCreateProgramFromFile(_context, CG_SOURCE,  path.c_str(),
     497                                CG_PROFILE_FP30, "lookupPosition", NULL);
     498    cgGLLoadProgram(_distanceSortLookupFP);
     499
     500    path = vrFilePath::getInstance()->getPath("mergesort.cg");
     501    _sortRecursionFP =
     502        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     503                                CG_PROFILE_FP30, "mergeSortRecursion", NULL);
     504    cgGLLoadProgram(_sortRecursionFP);
     505
     506    _srSizeParam = cgGetNamedParameter(_sortRecursionFP, "_Size");
     507    _srStepParam = cgGetNamedParameter(_sortRecursionFP, "_Step");
     508    _srCountParam = cgGetNamedParameter(_sortRecursionFP, "_Count");
     509
     510    _sortEndFP =
     511        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     512                                CG_PROFILE_FP30, "mergeSortEnd", NULL);
     513    cgGLLoadProgram(_sortEndFP);
     514
     515    _seSizeParam = cgGetNamedParameter(_sortEndFP, "size");
     516    _seStepParam = cgGetNamedParameter(_sortEndFP, "step");
     517
     518    path = vrFilePath::getInstance()->getPath("passthrough.cg");
     519    _passthroughFP =
     520        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     521                                CG_PROFILE_FP30, "main", NULL);
     522    cgGLLoadProgram(_passthroughFP);
     523
     524    _scaleParam = cgGetNamedParameter(_passthroughFP, "scale");
     525    _biasParam = cgGetNamedParameter(_passthroughFP, "bias");
     526
     527    path = vrFilePath::getInstance()->getPath("moveparticles.cg");
     528    _moveParticlesFP =
     529        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     530                                CG_PROFILE_FP30, "main", NULL);
     531    cgGLLoadProgram(_moveParticlesFP);
     532    _mpTimeScale = cgGetNamedParameter(_moveParticlesFP, "timeStep");
     533    _mpVectorField = cgGetNamedParameter(_moveParticlesFP, "vfield");
     534    _mpUseInitTex= cgGetNamedParameter(_moveParticlesFP, "useInitPos");
     535    _mpCurrentTime= cgGetNamedParameter(_moveParticlesFP, "currentTime");
     536    _mpMaxScale = cgGetNamedParameter(_moveParticlesFP, "maxScale");
     537    _mpScale= cgGetNamedParameter(_moveParticlesFP, "scale");
     538
     539    path = vrFilePath::getInstance()->getPath("particlevp.cg");
     540    _particleVP =
     541        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     542                                CG_PROFILE_VP40, "vpmain", NULL);
     543    cgGLLoadProgram(_particleVP);
     544    _mvpParticleParam = cgGetNamedParameter(_particleVP, "mvp");
     545    _mvParticleParam = cgGetNamedParameter(_particleVP, "modelview");
     546    _mvTanHalfFOVParam = cgGetNamedParameter(_particleVP, "tanHalfFOV");
     547    _mvCurrentTimeParam =  cgGetNamedParameter(_particleVP, "currentTime");
     548
     549    path = vrFilePath::getInstance()->getPath("particlefp.cg");
     550    _particleFP =
     551        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     552                                CG_PROFILE_FP40, "fpmain", NULL);
     553    cgGLLoadProgram(_particleFP);
     554    _vectorParticleParam = cgGetNamedParameter(_particleVP, "vfield");
     555
     556    path = vrFilePath::getInstance()->getPath("moveparticles.cg");
     557    _initParticlePosFP =
     558        cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
     559                                CG_PROFILE_FP30, "initParticlePosMain", NULL);
     560    cgGLLoadProgram(_initParticlePosFP);
     561    _ipVectorFieldParam = cgGetNamedParameter(_moveParticlesFP, "vfield");
     562}
     563
     564void ParticleSystem::passThoughPositions()
     565{
     566    cgGLBindProgram(_passthroughFP);
     567    cgGLEnableProfile(CG_PROFILE_FP30);
     568
     569    cgGLSetParameter4f(_scaleParam, 1.0, 1.0, 1.0, 1.0);
     570    cgGLSetParameter4f(_biasParam, 0.0, 0.0, 0.0, 0.0);
     571
     572    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
     573                 _width, _height, 0, GL_RGB, GL_FLOAT, (GLfloat *) _positionBuffer);
     574
     575    drawQuad();
     576
     577    cgGLDisableProfile(CG_PROFILE_FP30);
     578}
     579
     580void ParticleSystem::resetStreamlines()
     581{
     582    _currentStreamlineIndex = 0;
     583    _currentStreamlineOffset = 0;
     584    _curStepCount = 0;
     585}
     586
     587void ParticleSystem::reset()
     588{
     589    _currentTime = 0.0f;
     590    _sortBegin = 0;
     591    _sortEnd = _sortPassesPerFrame;
     592
     593    glPushAttrib(GL_VIEWPORT_BIT);
     594    glMatrixMode(GL_PROJECTION);
     595    glPushMatrix();
     596    glMatrixMode(GL_MODELVIEW);
     597
     598    resetStreamlines();
     599
     600    unsigned int maxsize = _userDefinedParticleMaxCount;
     601
     602    while (!_availableIndices.empty())
     603        _availableIndices.pop();
     604    while (!_activeParticles.empty())
     605        _activeParticles.pop();
     606
     607    _activeParticles.reserve(maxsize);
     608    _availableIndices.reserve(maxsize);
     609
     610    for (unsigned int i = 0; i < maxsize; i++)
     611        _availableIndices.push(i);
     612
     613    for (int i = 0; i < _particleMaxCount; i++) {
     614        _particles[i].timeOfBirth = -1.0f;
     615        _particles[i].lifeTime = 0.0f;
     616        _particles[i].attributeType = 0.0f;
     617        _particles[i].index = (float)i;
     618    }
     619
     620    glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
     621    Particle* pinfo = (Particle*) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY_ARB);
     622
     623    for (int i = 0; i < _particleMaxCount; i++) {
     624        pinfo[i] = _particles[i];
     625    }
    557626       
    558         _scaleParam = cgGetNamedParameter(_passthroughFP, "scale");
    559         _biasParam = cgGetNamedParameter(_passthroughFP, "bias");
    560 
    561 
    562         path = vrFilePath::getInstance()->getPath("moveparticles.cg");
    563         _moveParticlesFP =
    564                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    565                                                         CG_PROFILE_FP30, "main", NULL);
    566         cgGLLoadProgram(_moveParticlesFP);
    567         _mpTimeScale = cgGetNamedParameter(_moveParticlesFP, "timeStep");
    568         _mpVectorField = cgGetNamedParameter(_moveParticlesFP, "vfield");
    569         _mpUseInitTex= cgGetNamedParameter(_moveParticlesFP, "useInitPos");
    570         _mpCurrentTime= cgGetNamedParameter(_moveParticlesFP, "currentTime");
    571         _mpMaxScale = cgGetNamedParameter(_moveParticlesFP, "maxScale");
    572         _mpScale= cgGetNamedParameter(_moveParticlesFP, "scale");
    573 
    574        
    575         path = vrFilePath::getInstance()->getPath("particlevp.cg");
    576         _particleVP =
    577                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    578                                                         CG_PROFILE_VP40, "vpmain", NULL);
    579         cgGLLoadProgram(_particleVP);
    580         _mvpParticleParam = cgGetNamedParameter(_particleVP, "mvp");
    581         _mvParticleParam = cgGetNamedParameter(_particleVP, "modelview");
    582         _mvTanHalfFOVParam = cgGetNamedParameter(_particleVP, "tanHalfFOV");
    583         _mvCurrentTimeParam =  cgGetNamedParameter(_particleVP, "currentTime");
    584 
    585         path = vrFilePath::getInstance()->getPath("particlefp.cg");
    586         _particleFP =
    587                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    588                                                         CG_PROFILE_FP40, "fpmain", NULL);
    589         cgGLLoadProgram(_particleFP);
    590         _vectorParticleParam = cgGetNamedParameter(_particleVP, "vfield");
    591        
    592         path = vrFilePath::getInstance()->getPath("moveparticles.cg");
    593         _initParticlePosFP =
    594                 cgCreateProgramFromFile(_context, CG_SOURCE, path.c_str(),
    595                                 CG_PROFILE_FP30, "initParticlePosMain", NULL);
    596         cgGLLoadProgram(_initParticlePosFP);
    597         _ipVectorFieldParam = cgGetNamedParameter(_moveParticlesFP, "vfield");
    598 }
    599 
    600 void ParticleSystem::passThoughPositions()
    601 {
    602         cgGLBindProgram(_passthroughFP);
    603         cgGLEnableProfile(CG_PROFILE_FP30);
    604 
    605         cgGLSetParameter4f(_scaleParam, 1.0, 1.0, 1.0, 1.0);
    606         cgGLSetParameter4f(_biasParam, 0.0, 0.0, 0.0, 0.0);
    607 
    608        
    609         glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
    610                 _width, _height, 0, GL_RGB, GL_FLOAT, (GLfloat *) _positionBuffer);
    611        
    612         drawQuad();
    613 
    614         cgGLDisableProfile(CG_PROFILE_FP30);
    615 }
    616 
    617 
    618 void ParticleSystem::resetStreamlines()
    619 {
    620         _currentStreamlineIndex = 0;
    621         _currentStreamlineOffset = 0;
    622         _curStepCount = 0;
    623 }
    624 
    625 void ParticleSystem::reset()
    626 {
    627         _currentTime = 0.0f;
    628         _sortBegin = 0;
    629         _sortEnd = _sortPassesPerFrame;
    630 
    631         glPushAttrib(GL_VIEWPORT_BIT);
    632         glMatrixMode(GL_PROJECTION);
    633         glPushMatrix();
    634         glMatrixMode(GL_MODELVIEW);
    635 
    636         resetStreamlines();
    637 
    638         unsigned int maxsize = _userDefinedParticleMaxCount;
    639 
    640         while (!_availableIndices.empty())
    641                 _availableIndices.pop();
    642         while (!_activeParticles.empty())
    643                 _activeParticles.pop();
    644 
    645         _activeParticles.reserve(maxsize);
    646         _availableIndices.reserve(maxsize);
    647        
    648 
    649         for (unsigned int i = 0; i < maxsize; i++)
    650                 _availableIndices.push(i);
    651 
    652         for (int i = 0; i < _particleMaxCount; i++)
    653         {
    654                 _particles[i].timeOfBirth = -1.0f;
    655                 _particles[i].lifeTime = 0.0f;
    656                 _particles[i].attributeType = 0.0f;
    657                 _particles[i].index = (float)i;
    658         }
    659 
    660         glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
    661         Particle* pinfo = (Particle*) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY_ARB);
    662 
    663         for (int i = 0; i < _particleMaxCount; i++)
    664         {
    665                 pinfo[i] = _particles[i];
    666         }
    667        
    668         glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
    669 
    670         // POSITION
    671         memset(_positionBuffer, 0, sizeof(float3) * _width * _height);
    672         for(int y = 0; y < _height; y++)
    673         {
    674                 for(int x = 0; x < _width; x++)
    675                 {
    676                         _positionBuffer[_width * y + x].x = (float)rand() / (float) RAND_MAX;
    677                         //_positionBuffer[_width * y + x].x = 0.9;
    678                         _positionBuffer[_width * y + x].y = (float)rand() / (float) RAND_MAX;
    679                         _positionBuffer[_width * y + x].z = (float)rand() / (float) RAND_MAX;
    680                 }
    681         }
    682 
    683         glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
    684         glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
     627    glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
     628
     629    // POSITION
     630    memset(_positionBuffer, 0, sizeof(float3) * _width * _height);
     631    for (int y = 0; y < _height; y++) {
     632        for (int x = 0; x < _width; x++) {
     633            _positionBuffer[_width * y + x].x = (float)rand() / (float) RAND_MAX;
     634            //_positionBuffer[_width * y + x].x = 0.9;
     635            _positionBuffer[_width * y + x].y = (float)rand() / (float) RAND_MAX;
     636            _positionBuffer[_width * y + x].z = (float)rand() / (float) RAND_MAX;
     637        }
     638    }
     639
     640    glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
     641    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGB_NV,
    685642                 _width, _height, 0, GL_RGB, GL_FLOAT, (float*)_positionBuffer);
    686         glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
    687        
    688         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
    689         glViewport(0, 0, _width, _height);
    690         glMatrixMode(GL_PROJECTION);
    691         glLoadIdentity();
    692         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    693         glMatrixMode(GL_MODELVIEW);
    694         glLoadIdentity();
    695         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    696         passThoughPositions();
    697         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    698 
    699         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[_currentPosIndex]);
    700         glViewport(0, 0, _width, _height);
    701         glMatrixMode(GL_PROJECTION);
    702         glLoadIdentity();
    703         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    704         glMatrixMode(GL_MODELVIEW);
    705         glLoadIdentity();
    706         glClearColor(0, 0, 0, 0);
    707         glClear(GL_COLOR_BUFFER_BIT);
    708         // TBD..
    709         // velocity
    710         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    711 
    712 
    713         /// TBD...
    714         //DeathTimePBuffer->BeginCapture();
    715         //glClear(GL_COLOR_BUFFER_BIT);
    716         //DeathTimePBuffer->EndCapture();
    717 
    718         if (_sortEnabled)
    719         {
    720                 glDisable(GL_BLEND);
    721                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_currentSortIndex]);
    722                 glViewport(0, 0, _width, _height);
    723                 glMatrixMode(GL_PROJECTION);
    724                 glLoadIdentity();
    725                 glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    726                 glMatrixMode(GL_MODELVIEW);
    727                 glLoadIdentity();
    728 
    729                 cgGLBindProgram(_distanceInitFP);
    730                 cgGLEnableProfile(CG_PROFILE_FP30);
    731                
    732                 drawQuad();
    733 
    734                 cgGLDisableProfile(CG_PROFILE_FP30);
    735                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);           
    736 
    737                 _currentSortPass = 0;
    738                 this->_maxSortPasses = 100000;
    739         }
    740 
    741         glMatrixMode(GL_PROJECTION);
    742         glPopMatrix();
    743         glMatrixMode(GL_MODELVIEW);
    744         glPopAttrib();
     643    glBindTexture(GL_TEXTURE_RECTANGLE_NV, 0);
     644
     645    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
     646    glViewport(0, 0, _width, _height);
     647    glMatrixMode(GL_PROJECTION);
     648    glLoadIdentity();
     649    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     650    glMatrixMode(GL_MODELVIEW);
     651    glLoadIdentity();
     652    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     653    passThoughPositions();
     654    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     655
     656    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[_currentPosIndex]);
     657    glViewport(0, 0, _width, _height);
     658    glMatrixMode(GL_PROJECTION);
     659    glLoadIdentity();
     660    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     661    glMatrixMode(GL_MODELVIEW);
     662    glLoadIdentity();
     663    glClearColor(0, 0, 0, 0);
     664    glClear(GL_COLOR_BUFFER_BIT);
     665    // TBD..
     666    // velocity
     667    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     668
     669
     670    /// TBD...
     671    //DeathTimePBuffer->BeginCapture();
     672    //glClear(GL_COLOR_BUFFER_BIT);
     673    //DeathTimePBuffer->EndCapture();
     674
     675    if (_sortEnabled) {
     676        glDisable(GL_BLEND);
     677        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_currentSortIndex]);
     678        glViewport(0, 0, _width, _height);
     679        glMatrixMode(GL_PROJECTION);
     680        glLoadIdentity();
     681        glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     682        glMatrixMode(GL_MODELVIEW);
     683        glLoadIdentity();
     684
     685        cgGLBindProgram(_distanceInitFP);
     686        cgGLEnableProfile(CG_PROFILE_FP30);
     687
     688        drawQuad();
     689
     690        cgGLDisableProfile(CG_PROFILE_FP30);
     691        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);           
     692
     693        _currentSortPass = 0;
     694        this->_maxSortPasses = 100000;
     695    }
     696
     697    glMatrixMode(GL_PROJECTION);
     698    glPopMatrix();
     699    glMatrixMode(GL_MODELVIEW);
     700    glPopAttrib();
    745701}
    746702
    747703void ParticleSystem::createRenderTargets()
    748704{
    749         glGenFramebuffersEXT(2, psys_fbo);
     705    glGenFramebuffersEXT(2, psys_fbo);
    750706    glGenTextures(2, psys_tex);
    751707
    752708    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[0]);
    753    
    754         glViewport(0, 0, _width, _height);
    755         glMatrixMode(GL_PROJECTION);
    756         glLoadIdentity();
    757         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    758         glMatrixMode(GL_MODELVIEW);
    759         glLoadIdentity();
     709
     710    glViewport(0, 0, _width, _height);
     711    glMatrixMode(GL_PROJECTION);
     712    glLoadIdentity();
     713    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     714    glMatrixMode(GL_MODELVIEW);
     715    glLoadIdentity();
    760716
    761717    glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[0]);
    762718    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    763719    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    764         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    765         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     720    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     721    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    766722
    767723    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGBA32_NV,
    768         _width, _height, 0, GL_RGBA, GL_FLOAT, NULL);
     724                 _width, _height, 0, GL_RGBA, GL_FLOAT, NULL);
    769725
    770726    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
    771                 GL_TEXTURE_RECTANGLE_NV, psys_tex[0], 0);
    772        
     727                              GL_TEXTURE_RECTANGLE_NV, psys_tex[0], 0);
     728
    773729    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[1]);
    774730
    775731    glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[1]);
    776         glViewport(0, 0, _width, _height);
    777         glMatrixMode(GL_PROJECTION);
    778         glLoadIdentity();
    779         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    780         glMatrixMode(GL_MODELVIEW);
    781         glLoadIdentity();
     732    glViewport(0, 0, _width, _height);
     733    glMatrixMode(GL_PROJECTION);
     734    glLoadIdentity();
     735    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     736    glMatrixMode(GL_MODELVIEW);
     737    glLoadIdentity();
    782738
    783739    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    784740    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    785         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    786         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     741    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     742    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    787743
    788744    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, GL_FLOAT_RGBA32_NV,
    789         _width, _height, 0, GL_RGBA, GL_FLOAT, NULL);
     745                 _width, _height, 0, GL_RGBA, GL_FLOAT, NULL);
    790746
    791747    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
    792         GL_TEXTURE_RECTANGLE_NV, psys_tex[1], 0);
     748                              GL_TEXTURE_RECTANGLE_NV, psys_tex[1], 0);
    793749 
    794750    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     
    802758void ParticleSystem::createStreamlineRenderTargets()
    803759{
    804         glGenFramebuffersEXT(1, &_atlas_fbo);
    805         glGenTextures(1, &_atlas_tex);
    806         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _atlas_fbo);
    807         glViewport(0, 0, _atlasWidth, _atlasHeight);
    808         glMatrixMode(GL_PROJECTION);
    809         glLoadIdentity();
    810         glOrtho(0, _atlasWidth, 0, _atlasHeight, -10.0f, 10.0f);
    811         glMatrixMode(GL_MODELVIEW);
    812         glLoadIdentity();
    813 
    814         glBindTexture(ATLAS_TEXTURE_TARGET, _atlas_tex);
    815         glTexParameterf(ATLAS_TEXTURE_TARGET, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    816         glTexParameterf(ATLAS_TEXTURE_TARGET, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    817         //glTexParameteri(ATLAS_TEXTURE_TARGET, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    818         //glTexParameteri(ATLAS_TEXTURE_TARGET, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    819 
    820         glTexImage2D(ATLAS_TEXTURE_TARGET, 0, ATLAS_INTERNAL_TYPE,
    821                                         _atlasWidth, _atlasHeight, 0, GL_RGBA, GL_FLOAT, NULL);
    822 
    823         glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
    824                                                 ATLAS_TEXTURE_TARGET, _atlas_tex, 0);
     760    glGenFramebuffersEXT(1, &_atlas_fbo);
     761    glGenTextures(1, &_atlas_tex);
     762    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _atlas_fbo);
     763    glViewport(0, 0, _atlasWidth, _atlasHeight);
     764    glMatrixMode(GL_PROJECTION);
     765    glLoadIdentity();
     766    glOrtho(0, _atlasWidth, 0, _atlasHeight, -10.0f, 10.0f);
     767    glMatrixMode(GL_MODELVIEW);
     768    glLoadIdentity();
     769
     770    glBindTexture(ATLAS_TEXTURE_TARGET, _atlas_tex);
     771    glTexParameterf(ATLAS_TEXTURE_TARGET, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     772    glTexParameterf(ATLAS_TEXTURE_TARGET, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     773    //glTexParameteri(ATLAS_TEXTURE_TARGET, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     774    //glTexParameteri(ATLAS_TEXTURE_TARGET, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     775
     776    glTexImage2D(ATLAS_TEXTURE_TARGET, 0, ATLAS_INTERNAL_TYPE,
     777                 _atlasWidth, _atlasHeight, 0, GL_RGBA, GL_FLOAT, NULL);
     778
     779    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
     780                              ATLAS_TEXTURE_TARGET, _atlas_tex, 0);
    825781 
    826         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     782    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    827783}
    828784
     
    834790void ParticleSystem::createSortRenderTargets()
    835791{
    836         glGenFramebuffersEXT(2, sort_fbo);
     792    glGenFramebuffersEXT(2, sort_fbo);
    837793    glGenTextures(2, sort_tex);
    838794
    839795    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[0]);
    840         glViewport(0, 0, _width, _height);
    841         glMatrixMode(GL_PROJECTION);
    842         glLoadIdentity();
    843         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    844         glMatrixMode(GL_MODELVIEW);
    845         glLoadIdentity();
     796    glViewport(0, 0, _width, _height);
     797    glMatrixMode(GL_PROJECTION);
     798    glLoadIdentity();
     799    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     800    glMatrixMode(GL_MODELVIEW);
     801    glLoadIdentity();
    846802
    847803    glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[0]);
    848804    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    849805    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    850         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    851         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     806    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     807    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    852808    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, SORT_TEXTURE_INNER_FORMAT,
    853         _width, _height, 0, SORT_TEXTURE_FORMAT, GL_FLOAT, NULL);
    854        
     809                 _width, _height, 0, SORT_TEXTURE_FORMAT, GL_FLOAT, NULL);
     810
    855811    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
    856         GL_TEXTURE_RECTANGLE_NV, sort_tex[0], 0);
    857 
     812                              GL_TEXTURE_RECTANGLE_NV, sort_tex[0], 0);
    858813
    859814    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[1]);
    860         glViewport(0, 0, _width, _height);
    861         glMatrixMode(GL_PROJECTION);
    862         glLoadIdentity();
    863         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    864         glMatrixMode(GL_MODELVIEW);
    865         glLoadIdentity();
     815    glViewport(0, 0, _width, _height);
     816    glMatrixMode(GL_PROJECTION);
     817    glLoadIdentity();
     818    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     819    glMatrixMode(GL_MODELVIEW);
     820    glLoadIdentity();
    866821
    867822    glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[1]);
    868823    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    869824    glTexParameterf(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    870         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    871         glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     825    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     826    glTexParameteri(GL_TEXTURE_RECTANGLE_NV, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    872827    glTexImage2D(GL_TEXTURE_RECTANGLE_NV, 0, SORT_TEXTURE_INNER_FORMAT,
    873         _width, _height, 0, SORT_TEXTURE_FORMAT, GL_FLOAT, NULL);
     828                 _width, _height, 0, SORT_TEXTURE_FORMAT, GL_FLOAT, NULL);
    874829
    875830    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
    876                                         GL_TEXTURE_RECTANGLE_NV, sort_tex[1], 0);
    877  
     831                              GL_TEXTURE_RECTANGLE_NV, sort_tex[1], 0);
     832
    878833    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    879834}
     
    881836ParticleSystem::~ParticleSystem()
    882837{
    883         std::vector<ParticleEmitter*>::iterator iter;
    884         for (iter = _emitters.begin(); iter != _emitters.end(); ++iter)
    885                 delete (*iter);
    886 
    887         // Particle Position
    888         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[0]);
     838    std::vector<ParticleEmitter*>::iterator iter;
     839    for (iter = _emitters.begin(); iter != _emitters.end(); ++iter)
     840        delete (*iter);
     841
     842    // Particle Position
     843    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[0]);
    889844    glDeleteTextures(1, psys_tex);
    890845    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[1]);
    891846    glDeleteTextures(1, psys_tex+1);
    892         glDeleteFramebuffersEXT(2, psys_fbo);
    893 
    894         // Sort
    895         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[0]);
     847    glDeleteFramebuffersEXT(2, psys_fbo);
     848
     849    // Sort
     850    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[0]);
    896851    glDeleteTextures(1, sort_tex);
    897852    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[1]);
    898853    glDeleteTextures(1, sort_tex+1);
    899         glDeleteFramebuffersEXT(2, sort_fbo);
    900 
    901         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[0]);
     854    glDeleteFramebuffersEXT(2, sort_fbo);
     855
     856    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[0]);
    902857    glDeleteTextures(1, velocity_tex);
    903858    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, velocity_fbo[1]);
    904859    glDeleteTextures(1, velocity_tex+1);
    905         glDeleteFramebuffersEXT(2, velocity_fbo);
    906 
    907         if (_vertices) delete _vertices;
    908 
    909         delete [] _particles;
    910         delete [] _positionBuffer;
    911         delete [] _colorBuffer;
    912 
    913         if (_arrows) delete _arrows;
    914 
    915         // STREAM LINE
    916         if (_streamVertices) delete _streamVertices;
    917         if (_indexBuffer) delete _indexBuffer;
    918 
    919 
    920         ////////////////////////////////////////
    921         cgDestroyProgram(_distanceInitFP);
    922 
    923         ////////////////////////////////////////
    924         cgDestroyParameter(_viewPosParam);
    925         cgDestroyProgram(_distanceSortFP);
    926 
    927         ////////////////////////////////////////
    928         cgDestroyProgram(_distanceSortLookupFP);
    929 
    930         ////////////////////////////////////////
    931         cgDestroyParameter(_scaleParam);
    932         cgDestroyParameter(_biasParam);
    933         cgDestroyProgram(_passthroughFP);
    934 
    935         ////////////////////////////////////////
     860    glDeleteFramebuffersEXT(2, velocity_fbo);
     861
     862    if (_vertices) delete _vertices;
     863
     864    delete [] _particles;
     865    delete [] _positionBuffer;
     866    delete [] _colorBuffer;
     867
     868    if (_arrows) delete _arrows;
     869
     870    // STREAM LINE
     871    if (_streamVertices) delete _streamVertices;
     872    if (_indexBuffer) delete _indexBuffer;
     873
     874    cgDestroyProgram(_distanceInitFP);
     875
     876    cgDestroyParameter(_viewPosParam);
     877    cgDestroyProgram(_distanceSortFP);
     878
     879    cgDestroyProgram(_distanceSortLookupFP);
     880
     881    cgDestroyParameter(_scaleParam);
     882    cgDestroyParameter(_biasParam);
     883    cgDestroyProgram(_passthroughFP);
     884
     885    cgDestroyParameter(_srSizeParam);
     886    cgDestroyParameter(_srStepParam);
     887    cgDestroyParameter(_srCountParam);
     888
     889    cgDestroyProgram(_sortRecursionFP);
     890
     891    cgDestroyParameter(_seSizeParam);
     892    cgDestroyParameter(_seStepParam);
     893    cgDestroyProgram(_sortEndFP);
     894
     895    cgDestroyParameter(_mpTimeScale);
     896    cgDestroyParameter(_mpVectorField);
     897    cgDestroyParameter(_mpUseInitTex);
     898    cgDestroyParameter(_mpCurrentTime);
     899    cgDestroyProgram(_moveParticlesFP);
     900
     901    cgDestroyParameter(_ipVectorFieldParam);
     902    cgDestroyProgram(_initParticlePosFP);
     903
     904    cgDestroyParameter(_mvpParticleParam);
     905    cgDestroyParameter(_mvParticleParam);
     906    cgDestroyParameter(_mvTanHalfFOVParam);
     907    cgDestroyParameter(_mvCurrentTimeParam);
     908    cgDestroyProgram(_particleFP);
     909
     910    cgDestroyParameter(_vectorParticleParam);
     911    cgDestroyProgram(_particleVP);
     912}
     913
     914bool ParticleSystem::isEnabled(EnableEnum enabled)
     915{
     916    switch (enabled) {
     917    case PS_SORT :
     918        return _sortEnabled;
     919        break;
     920    case PS_GLYPE :
     921        return _glypEnabled;
     922        break;
     923    case PS_DRAW_BBOX :
     924        return _drawBBoxEnabled;
     925        break;
     926    case PS_ADVECTION :
     927        return _advectionEnabled;
     928    case PS_STREAMLINE :
     929        return _streamlineEnabled;
     930    }
     931    return false;
     932}
     933
     934void ParticleSystem::enable(EnableEnum enabled)
     935{
     936    switch (enabled) {
     937    case PS_SORT :
     938        _sortEnabled = true;
     939        break;
     940    case PS_GLYPE :
     941        _glypEnabled = true;
     942        break;
     943    case PS_DRAW_BBOX :
     944        _drawBBoxEnabled = true;
     945        break;
     946    case PS_ADVECTION :
     947        _advectionEnabled = true;
     948        break;
     949    case PS_STREAMLINE :
     950        _streamlineEnabled = true;
     951        break;
     952    }
     953}
     954
     955void ParticleSystem::disable(EnableEnum enabled)
     956{
     957    switch (enabled) {
     958    case PS_SORT :
     959        _sortEnabled = false;
     960        break;
     961    case PS_GLYPE :
     962        _glypEnabled = false;
     963        break;
     964    case PS_DRAW_BBOX :
     965        _drawBBoxEnabled = false;
     966        break;
     967    case PS_ADVECTION :
     968        _advectionEnabled = false;
     969        break;
     970    case PS_STREAMLINE :
     971        _streamlineEnabled = false;
     972        break;
     973    }
     974}
     975
     976void ParticleSystem::advectStreamlines()
     977{
     978    glDisable(GL_BLEND);
     979    glDisable(GL_DEPTH_TEST);
    936980       
    937         cgDestroyParameter(_srSizeParam);
    938         cgDestroyParameter(_srStepParam);
    939         cgDestroyParameter(_srCountParam);
     981    //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
     982    //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     983
     984    glPushAttrib(GL_VIEWPORT_BIT);
     985    glViewport(0, 0, _width, _height);
     986    glMatrixMode(GL_PROJECTION);
     987    glPushMatrix();
     988    glLoadIdentity();
     989    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     990    glMatrixMode(GL_MODELVIEW);
     991    glPushMatrix();
     992    glLoadIdentity();
     993
     994    glEnable(GL_TEXTURE_RECTANGLE_NV);
     995
     996    cgGLBindProgram(_moveParticlesFP);
     997    cgGLEnableProfile(CG_PROFILE_FP30);
     998    cgGLSetParameter1f(_mpTimeScale, 0.005);
     999    cgGLSetParameter1f(_mpUseInitTex, 1.0);
     1000    cgGLSetParameter1f(_mpCurrentTime, _currentTime);
     1001    cgGLSetParameter3f(_mpScale, _scalex, _scaley, _scalez);
     1002    cgGLSetParameter1f(_mpMaxScale, _maxVelocityScale);
     1003    cgGLSetTextureParameter(_mpVectorField, _curVectorFieldID);
     1004    cgGLEnableTextureParameter(_mpVectorField);
     1005
     1006    for (int i = 0; i < _stepSizeStreamline; ++i) {
     1007        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
     1008        glClear(GL_COLOR_BUFFER_BIT);
     1009        glActiveTextureARB(GL_TEXTURE0_ARB);
     1010        glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
     1011        glActiveTextureARB(GL_TEXTURE1_ARB);
     1012        glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
     1013        drawQuad();
     1014        swap(_currentPosIndex, _destPosIndex);
     1015    }
     1016
     1017    cgGLDisableTextureParameter(_mpVectorField);
     1018    glDisable(GL_TEXTURE_RECTANGLE_NV);
     1019    cgGLDisableProfile(CG_PROFILE_FP30);
     1020
     1021    glMatrixMode(GL_PROJECTION);
     1022    glPopMatrix();
     1023    glMatrixMode(GL_MODELVIEW);
     1024    glPopMatrix();
     1025    glPopAttrib();
     1026    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1027
     1028    if (_currentStreamlineIndex < _maxAtlasCount) {
     1029        int xoffset = (_currentStreamlineIndex % _atlas_x) * _width;
     1030        int yoffset = (_currentStreamlineIndex / _atlas_x) * _height;
     1031
     1032        glActiveTextureARB(GL_TEXTURE0_ARB);
     1033        glEnable(ATLAS_TEXTURE_TARGET);
     1034        glBindTexture(ATLAS_TEXTURE_TARGET, _atlas_tex);
     1035
     1036        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
     1037        //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
     1038        glCopyTexSubImage2D(ATLAS_TEXTURE_TARGET, 0, xoffset, yoffset,
     1039                            0, 0, _width, _height);
     1040        glActiveTextureARB(GL_TEXTURE0_ARB);
     1041        glBindTexture(ATLAS_TEXTURE_TARGET, 0);
     1042        glDisable(ATLAS_TEXTURE_TARGET);
     1043
     1044        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _atlas_fbo);
     1045        _streamVertices->Read(_atlasWidth, _atlasHeight);
     1046        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1047        _currentStreamlineIndex++;
     1048
     1049        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1050    }
     1051}
     1052
     1053bool ParticleSystem::advect(float deltaT, float camx, float camy, float camz)
     1054{
     1055    static bool firstLoad = true;
     1056    if (this->isTimeVaryingField()) {
     1057        static float oldTime = vrGetTimeStamp();
     1058        static int index = 0;
     1059        float time = vrGetTimeStamp();
     1060        if ((time - oldTime) > 2.0) {
     1061            if (!_queue.isEmpty()) {
     1062                float* data = 0;
     1063                if (_queue.top(data)) {
     1064                    float t = clock() /(float) CLOCKS_PER_SEC;
     1065                    _vectorFields[0]->updatePixels(data);
     1066                    float ti = clock() / (float) CLOCKS_PER_SEC;
     1067                    TRACE("pixels %f\n",ti - t);
     1068                    _queue.pop();
     1069                    oldTime = time;
     1070
     1071                    firstLoad = false;
     1072                    TRACE("%d bound\n", index++);
     1073                }
     1074            }           
     1075        }
     1076        if (firstLoad) return false;
     1077    }
     1078
     1079    if (!_advectionEnabled) return true;
     1080    if (this->_streamlineEnabled) {
     1081        advectStreamlines();
     1082        _currentTime += deltaT;
     1083    } else {
     1084        _camx = camx;
     1085        _camy = camy;
     1086        _camz = camz;
     1087
     1088        glDisable(GL_BLEND);
     1089        glDisable(GL_DEPTH_TEST);
     1090
     1091        glPushAttrib(GL_VIEWPORT_BIT);
     1092        glViewport(0, 0, _width, _height);
     1093        glMatrixMode(GL_PROJECTION);
     1094        glPushMatrix();
     1095        glLoadIdentity();
     1096        glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     1097        glMatrixMode(GL_MODELVIEW);
     1098        glPushMatrix();
     1099        glLoadIdentity();
     1100
     1101        glEnable(GL_TEXTURE_RECTANGLE_NV);
     1102
     1103        cgGLBindProgram(_moveParticlesFP);
     1104        cgGLEnableProfile(CG_PROFILE_FP30);
     1105
     1106        // INSOO
     1107        // TIME SCALE
     1108
     1109#ifdef USE_TORNADOR
     1110        cgGLSetParameter1f(_mpTimeScale, 1.0);
     1111#else
     1112        cgGLSetParameter1f(_mpTimeScale, 0.005);
     1113        //cgGLSetParameter1f(_mpTimeScale, 0.5);
     1114#endif
     1115        //cgGLSetParameter1f(_mpTimeScale, 0.1);
     1116
     1117        //////////////////////////////////////////////////////
     1118        // UPDATE POS
     1119        cgGLSetTextureParameter(_mpVectorField, _curVectorFieldID);
     1120        cgGLEnableTextureParameter(_mpVectorField);
     1121        cgGLSetParameter3f(_mpScale, _scalex, _scaley, _scalez);
     1122        cgGLSetParameter1f(_mpMaxScale, _maxVelocityScale);
     1123        for (int i = 0; i < _stepSizeStreamline; ++i) {
     1124            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
     1125            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     1126            glActiveTextureARB(GL_TEXTURE0_ARB);
     1127            glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
     1128            glActiveTextureARB(GL_TEXTURE1_ARB);
     1129            glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
     1130            drawQuad();
     1131            swap(_currentPosIndex, _destPosIndex);
     1132        }
     1133        cgGLDisableTextureParameter(_mpVectorField);
     1134
     1135        glActiveTextureARB(GL_TEXTURE1_ARB);
     1136        glDisable(GL_TEXTURE_RECTANGLE_NV);
     1137        glActiveTextureARB(GL_TEXTURE0_ARB);
     1138        glDisable(GL_TEXTURE_RECTANGLE_NV);
     1139
     1140        glDisable(GL_TEXTURE_RECTANGLE_NV);
     1141        cgGLDisableProfile(CG_PROFILE_FP30);
     1142
     1143        glMatrixMode(GL_PROJECTION);
     1144        glPopMatrix();
     1145        glMatrixMode(GL_MODELVIEW);
     1146        glPopMatrix();
     1147        glPopAttrib();
     1148        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1149
     1150        if (_sortEnabled) {
     1151            sort();
     1152
     1153            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
     1154            _vertices->Read(_width, _height);
     1155            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1156        } else {
     1157            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
     1158            _vertices->Read(_width, _height);
     1159            glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1160        }
     1161
     1162        // NEW PARTICLES
     1163        for (unsigned int i = 0; i < _emitters.size(); ++i) {
     1164            // TBD..
     1165            unsigned int numOfNewParticles = randomRange(_emitters[i]->_minNumOfNewParticles, _emitters[i]->_maxNumOfNewParticles) * deltaT;
     1166            for (unsigned int k = 0; k < numOfNewParticles; ++k) {
     1167                float3 position = _emitters[i]->_position;
     1168                position += _emitters[i]->_maxPositionOffset *
     1169                    float3(randomRange(-1.0f, 1.0f), randomRange(-1.0f, 1.0f), randomRange(-1.0f, 1.0f));
     1170
     1171                float lifetime = randomRange(_emitters[i]->_minLifeTime, _emitters[i]->_maxLifeTime);
     1172
     1173                // TBD..
     1174                allocateParticle(position, float3(0.0f, 0.0f, 0.0f),  lifetime, 1 - (float) k / numOfNewParticles);
     1175            }
     1176        }
     1177
     1178        initNewParticles();
     1179
     1180        _currentTime += deltaT;
     1181
     1182        cleanUpParticles();
     1183    }
     1184
     1185    return true;
     1186}
     1187
     1188void ParticleSystem::allocateParticle(const float3& position, const float3& velocity,
     1189                                      float lifeTime, float initTimeStep)
     1190{
     1191    if (_availableIndices.empty()) {
     1192        return;
     1193    }
     1194
     1195    int index = _availableIndices.top();
     1196    _availableIndices.pop();
     1197
     1198    ActiveParticle p;
     1199    p.index = index;
     1200    p.timeOfDeath = _currentTime + lifeTime;
     1201    _activeParticles.push(p);
     1202
     1203    NewParticle newParticle;
     1204    newParticle.index = index;
     1205    newParticle.position = position;
     1206    newParticle.velocity = velocity;
     1207    newParticle.timeOfDeath = p.timeOfDeath;
     1208    newParticle.initTimeStep = initTimeStep;
     1209
     1210    _newParticles.push_back(newParticle);
     1211
     1212    _particles[index].timeOfBirth = _currentTime;
     1213    _particles[index].lifeTime = lifeTime;
     1214}
     1215
     1216void ParticleSystem::initNewParticles()
     1217{
     1218    /////////////////////////////
     1219    // INIT NEW PARTICLE
     1220    glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
     1221    Particle* pinfo = (Particle*) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY_ARB);
     1222
     1223    std::vector<NewParticle>::iterator iter;
     1224    for (iter = _newParticles.begin(); iter != _newParticles.end(); ++iter) {
     1225        pinfo[iter->index] = _particles[iter->index];
     1226    }
     1227
     1228    glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
     1229
     1230    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
     1231
     1232    glPushAttrib(GL_VIEWPORT_BIT);
     1233    glViewport(0, 0, _width, _height);
     1234    glMatrixMode(GL_PROJECTION);
     1235    glPushMatrix();
     1236    glLoadIdentity();
     1237    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     1238    glMatrixMode(GL_MODELVIEW);
     1239    glPushMatrix();
     1240    glLoadIdentity();
     1241
     1242    cgGLBindProgram(_initParticlePosFP);
     1243    cgGLEnableProfile(CG_PROFILE_FP30);
     1244    cgGLSetTextureParameter(_ipVectorFieldParam, _curVectorFieldID);
     1245    cgGLEnableTextureParameter(_ipVectorFieldParam);
     1246    // TBD..
     1247    //glActiveTextureARB(GL_TEXTURE0_ARB);
     1248    //VelocityPBuffers[VelocityCurrent]->Bind();
     1249
     1250    glActiveTextureARB(GL_TEXTURE0_ARB);
     1251    glEnable(GL_TEXTURE_RECTANGLE_NV);
     1252    glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_destPosIndex]);
     1253
     1254    glBegin(GL_POINTS);
     1255    for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++) {
     1256        //TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
     1257        glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
     1258
     1259        // TBD..
     1260        //glMultiTexCoord2f(GL_TEXTURE1_ARB, (float)(i->Index % Width), (float)(i->Index / Height));
     1261        //glMultiTexCoord1f(GL_TEXTURE2_ARB, iter->initTimeStep);
     1262
     1263        glVertex2f((float)(iter->index % _width),
     1264                   (float)(iter->index / _height) + 1/* + offsetY*/ /* + offsetY shouldn't be */);
     1265        //TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
     1266    }
     1267    glEnd();
     1268
     1269    glDisable(GL_TEXTURE_RECTANGLE_NV);
     1270    cgGLDisableTextureParameter(_ipVectorFieldParam);
     1271    cgGLDisableProfile(CG_PROFILE_FP30);
     1272
     1273    glMatrixMode(GL_PROJECTION);
     1274    glPopMatrix();
     1275    glMatrixMode(GL_MODELVIEW);
     1276    glPopMatrix();
     1277    glPopAttrib();
     1278
     1279    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    9401280       
    941         cgDestroyProgram(_sortRecursionFP);
    942 
    943        
    944         cgDestroyParameter(_seSizeParam);
    945         cgDestroyParameter(_seStepParam);
    946         cgDestroyProgram(_sortEndFP);
    947 
    948        
    949         cgDestroyParameter(_mpTimeScale);
    950         cgDestroyParameter(_mpVectorField);
    951         cgDestroyParameter(_mpUseInitTex);
    952         cgDestroyParameter(_mpCurrentTime);
    953         cgDestroyProgram(_moveParticlesFP);
    954 
    955        
    956         cgDestroyParameter(_ipVectorFieldParam);
    957         cgDestroyProgram(_initParticlePosFP);
    958        
    959         cgDestroyParameter(_mvpParticleParam);
    960         cgDestroyParameter(_mvParticleParam);
    961         cgDestroyParameter(_mvTanHalfFOVParam);
    962         cgDestroyParameter(_mvCurrentTimeParam);
    963         cgDestroyProgram(_particleFP);
    964 
    965         cgDestroyParameter(_vectorParticleParam);
    966         cgDestroyProgram(_particleVP);
    967 }
    968 
    969 bool ParticleSystem::isEnabled(EnableEnum enabled)
    970 {
    971         switch (enabled)
    972         {
    973         case PS_SORT :
    974                 return _sortEnabled;
    975                 break;
    976         case PS_GLYPE :
    977                 return _glypEnabled;
    978                 break;
    979         case PS_DRAW_BBOX :
    980                 return _drawBBoxEnabled;
    981                 break;
    982         case PS_ADVECTION :
    983                 return _advectionEnabled;
    984         case PS_STREAMLINE :
    985                 return _streamlineEnabled;
    986         }
    987         return false;
    988 }
    989 
    990 void ParticleSystem::enable(EnableEnum enabled)
    991 {
    992         switch (enabled)
    993         {
    994         case PS_SORT :
    995                 _sortEnabled = true;
    996                 break;
    997         case PS_GLYPE :
    998                 _glypEnabled = true;
    999                 break;
    1000         case PS_DRAW_BBOX :
    1001                 _drawBBoxEnabled = true;
    1002                 break;
    1003         case PS_ADVECTION :
    1004                 _advectionEnabled = true;
    1005                 break;
    1006         case PS_STREAMLINE :
    1007                 _streamlineEnabled = true;
    1008                 break;
    1009         }
    1010 }
    1011 
    1012 void ParticleSystem::disable(EnableEnum enabled)
    1013 {
    1014         switch (enabled)
    1015         {
    1016         case PS_SORT :
    1017                 _sortEnabled = false;
    1018                 break;
    1019         case PS_GLYPE :
    1020                 _glypEnabled = false;
    1021                 break;
    1022         case PS_DRAW_BBOX :
    1023                 _drawBBoxEnabled = false;
    1024                 break;
    1025         case PS_ADVECTION :
    1026                 _advectionEnabled = false;
    1027                 break;
    1028         case PS_STREAMLINE :
    1029                 _streamlineEnabled = false;
    1030                 break;
    1031         }
    1032 }
    1033 
    1034 void ParticleSystem::advectStreamlines()
    1035 {
    1036         glDisable(GL_BLEND);
    1037         glDisable(GL_DEPTH_TEST);
    1038        
    1039        
    1040         //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
    1041         //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    1042 
    1043         glPushAttrib(GL_VIEWPORT_BIT);
    1044         glViewport(0, 0, _width, _height);
    1045         glMatrixMode(GL_PROJECTION);
    1046         glPushMatrix();
    1047         glLoadIdentity();
    1048         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1049         glMatrixMode(GL_MODELVIEW);
    1050         glPushMatrix();
    1051         glLoadIdentity();
    1052        
    1053         glEnable(GL_TEXTURE_RECTANGLE_NV);
    1054 
    1055         cgGLBindProgram(_moveParticlesFP);
    1056         cgGLEnableProfile(CG_PROFILE_FP30);
    1057         cgGLSetParameter1f(_mpTimeScale, 0.005);
    1058         cgGLSetParameter1f(_mpUseInitTex, 1.0);
    1059         cgGLSetParameter1f(_mpCurrentTime, _currentTime);
    1060         cgGLSetParameter3f(_mpScale, _scalex, _scaley, _scalez);
    1061         cgGLSetParameter1f(_mpMaxScale, _maxVelocityScale);
    1062         cgGLSetTextureParameter(_mpVectorField, _curVectorFieldID);
    1063         cgGLEnableTextureParameter(_mpVectorField);
    1064 
    1065        
    1066         for (int i = 0; i < _stepSizeStreamline; ++i)
    1067         {
    1068                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
    1069                 glClear(GL_COLOR_BUFFER_BIT);
    1070                 glActiveTextureARB(GL_TEXTURE0_ARB);
    1071                 glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
    1072                 glActiveTextureARB(GL_TEXTURE1_ARB);
    1073                 glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
    1074                 drawQuad();
    1075                 swap(_currentPosIndex, _destPosIndex);
    1076         }
    1077 
    1078         cgGLDisableTextureParameter(_mpVectorField);
    1079         glDisable(GL_TEXTURE_RECTANGLE_NV);
    1080         cgGLDisableProfile(CG_PROFILE_FP30);
    1081    
    1082         glMatrixMode(GL_PROJECTION);
    1083         glPopMatrix();
    1084         glMatrixMode(GL_MODELVIEW);
    1085         glPopMatrix();
    1086         glPopAttrib();
    1087         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1088 
    1089         if (_currentStreamlineIndex < _maxAtlasCount)
    1090         {
    1091                 int xoffset = (_currentStreamlineIndex % _atlas_x) * _width;
    1092                 int yoffset = (_currentStreamlineIndex / _atlas_x) * _height;
    1093                
    1094                
    1095                 glActiveTextureARB(GL_TEXTURE0_ARB);
    1096                 glEnable(ATLAS_TEXTURE_TARGET);
    1097                 glBindTexture(ATLAS_TEXTURE_TARGET, _atlas_tex);
    1098 
    1099                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
    1100                 //glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
    1101                 glCopyTexSubImage2D(ATLAS_TEXTURE_TARGET, 0, xoffset, yoffset,
    1102                                                 0, 0, _width, _height);
    1103                 glActiveTextureARB(GL_TEXTURE0_ARB);
    1104                 glBindTexture(ATLAS_TEXTURE_TARGET, 0);
    1105                 glDisable(ATLAS_TEXTURE_TARGET);
    1106 
    1107                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _atlas_fbo);
    1108                 _streamVertices->Read(_atlasWidth, _atlasHeight);
    1109                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1110                 _currentStreamlineIndex++;
    1111 
    1112                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1113         }
    1114        
    1115 }
    1116 
    1117 bool ParticleSystem::advect(float deltaT, float camx, float camy, float camz)
    1118 {
    1119         static bool firstLoad = true;
    1120         if (this->isTimeVaryingField())
    1121         {
    1122                 static float oldTime = vrGetTimeStamp();
    1123                 static int index = 0;
    1124                 float time = vrGetTimeStamp();
    1125                 if ((time - oldTime) > 2.0)
    1126                 {
    1127                         if (!_queue.isEmpty())
    1128                         {
    1129                                 float* data = 0;
    1130                                 if (_queue.top(data))
    1131                                 {
    1132                                         float t = clock() /(float) CLOCKS_PER_SEC;
    1133                                         _vectorFields[0]->updatePixels(data);
    1134                                         float ti = clock() / (float) CLOCKS_PER_SEC;
    1135                                         TRACE("pixels %f\n",ti - t);
    1136                                         _queue.pop();
    1137                                         oldTime = time;
    1138 
    1139                                         firstLoad = false;
    1140                                         TRACE("%d bound\n", index++);
    1141                                 }
    1142                         }               
    1143                 }
    1144                 if (firstLoad) return false;
    1145         }
    1146 
    1147         if (!_advectionEnabled) return true;
    1148         if (this->_streamlineEnabled)
    1149         {
    1150                 advectStreamlines();
    1151                 _currentTime += deltaT;
    1152         }
    1153         else
    1154         {
    1155 
    1156                 _camx = camx;
    1157                 _camy = camy;
    1158                 _camz = camz;
    1159 
    1160                 glDisable(GL_BLEND);
    1161                 glDisable(GL_DEPTH_TEST);
    1162                
    1163                
    1164                 glPushAttrib(GL_VIEWPORT_BIT);
    1165                 glViewport(0, 0, _width, _height);
    1166                 glMatrixMode(GL_PROJECTION);
    1167                 glPushMatrix();
    1168                 glLoadIdentity();
    1169                 glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1170                 glMatrixMode(GL_MODELVIEW);
    1171                 glPushMatrix();
    1172                 glLoadIdentity();
    1173                
    1174                 glEnable(GL_TEXTURE_RECTANGLE_NV);
    1175 
    1176 
    1177                 cgGLBindProgram(_moveParticlesFP);
    1178                 cgGLEnableProfile(CG_PROFILE_FP30);
    1179 
    1180 // INSOO
    1181 // TIME SCALE
    1182                
    1183 #ifdef USE_TORNADOR
    1184                 cgGLSetParameter1f(_mpTimeScale, 1.0);
     1281    // INIT NEW END
     1282    /////////////////////////////
     1283#if 1
     1284    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _initPos_fbo);
     1285    glPushAttrib(GL_VIEWPORT_BIT);
     1286    glViewport(0, 0, _width, _height);
     1287    glMatrixMode(GL_PROJECTION);
     1288    glPushMatrix();
     1289    glLoadIdentity();
     1290    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     1291    glMatrixMode(GL_MODELVIEW);
     1292    glPushMatrix();
     1293    glLoadIdentity();
     1294
     1295    cgGLBindProgram(_initParticlePosFP);
     1296    cgGLEnableProfile(CG_PROFILE_FP30);
     1297    cgGLSetTextureParameter(_ipVectorFieldParam, _curVectorFieldID);
     1298    cgGLEnableTextureParameter(_ipVectorFieldParam);
     1299    // TBD..
     1300    //glActiveTextureARB(GL_TEXTURE0_ARB);
     1301    //VelocityPBuffers[VelocityCurrent]->Bind();
     1302
     1303    glActiveTextureARB(GL_TEXTURE0_ARB);
     1304    glEnable(GL_TEXTURE_RECTANGLE_NV);
     1305    //glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
     1306    glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_destPosIndex]);
     1307
     1308    glBegin(GL_POINTS);
     1309    for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++) {
     1310        //TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
     1311        glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
     1312
     1313        // TBD..
     1314        //glMultiTexCoord2f(GL_TEXTURE1_ARB, (float)(i->Index % Width), (float)(i->Index / Height));
     1315        //glMultiTexCoord1f(GL_TEXTURE2_ARB, iter->initTimeStep);
     1316
     1317        glVertex2f((float)(iter->index % _width),
     1318                   (float)(iter->index / _height) + 1/* + offsetY*/ /* + offsetY shouldn't be */);
     1319        //TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
     1320    }
     1321    glEnd();
     1322
     1323    glDisable(GL_TEXTURE_RECTANGLE_NV);
     1324    cgGLDisableTextureParameter(_ipVectorFieldParam);
     1325    cgGLDisableProfile(CG_PROFILE_FP30);
     1326
     1327    glMatrixMode(GL_PROJECTION);
     1328    glPopMatrix();
     1329    glMatrixMode(GL_MODELVIEW);
     1330    glPopMatrix();
     1331    glPopAttrib();
     1332
     1333    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1334#endif
     1335
     1336    // Free array.
     1337    _newParticles.clear();
     1338}
     1339
     1340void ParticleSystem::cleanUpParticles()
     1341{
     1342    if (! _activeParticles.empty()) {
     1343        while (_activeParticles.top().timeOfDeath < _currentTime) {
     1344            unsigned int i = _activeParticles.top().index;
     1345            _activeParticles.pop();
     1346            _availableIndices.push(i);
     1347            //_usedIndices[i] = false;
     1348
     1349            //if (i >= _maxUsedIndex)
     1350            //  while (!_usedIndices[_maxUsedIndex])
     1351            //          _maxUsedIndex--;
     1352        }
     1353    }
     1354}
     1355
     1356void ParticleSystem::sort()
     1357{
     1358    ///////////////////////////////////////////////////////////
     1359    // BEGIN - COMPUTE DISTANCE
     1360    vrVector3f pos;
     1361    vrMatrix4x4f mat;
     1362    glPushMatrix();
     1363    glLoadIdentity();
     1364    glScalef(_scalex, _scaley, _scalez);
     1365    glTranslatef(-0.5f, -0.5f, -0.5f);
     1366    glGetFloatv(GL_MODELVIEW_MATRIX, mat.get());
     1367    glPopMatrix();
     1368    mat.invert();
     1369    mat.getTranslation(pos);
     1370
     1371    cgGLBindProgram(_distanceSortFP);
     1372    cgGLEnableProfile(CG_PROFILE_FP30);
     1373
     1374    glActiveTextureARB(GL_TEXTURE0_ARB);
     1375    glEnable(GL_TEXTURE_RECTANGLE_NV);
     1376    glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[_currentSortIndex]);
     1377
     1378    glActiveTextureARB(GL_TEXTURE1_ARB);
     1379    glEnable(GL_TEXTURE_RECTANGLE_NV);
     1380    glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
     1381
     1382    cgGLSetParameter3f(_viewPosParam, pos.x, pos.y, pos.z);
     1383
     1384    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
     1385    glPushAttrib(GL_VIEWPORT_BIT);
     1386    glViewport(0, 0, _width, _height);
     1387    glMatrixMode(GL_PROJECTION);
     1388    glPushMatrix();
     1389    glLoadIdentity();
     1390    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     1391    glMatrixMode(GL_MODELVIEW);
     1392    glPushMatrix();
     1393    glLoadIdentity();
     1394
     1395    drawQuad();
     1396
     1397    cgGLDisableProfile(CG_PROFILE_FP30);
     1398
     1399    glMatrixMode(GL_PROJECTION);
     1400    glPopMatrix();
     1401    glMatrixMode(GL_MODELVIEW);
     1402    glPopMatrix();
     1403    glPopAttrib();
     1404    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1405
     1406    // _DEBUG
     1407    /*
     1408    {
     1409        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
     1410        static float debug[256];
     1411        glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
     1412        TRACE("[%d]", _currentSortIndex);
     1413        for (int i = 0; i < _width * _height * 3; i += 3)
     1414            TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
     1415        TRACE("\n");
     1416        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1417    }
     1418    */
     1419
     1420    // _DEBUG
     1421    /*
     1422    {
     1423        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
     1424        static float debug[256];
     1425        glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
     1426        TRACE("\n");
     1427        TRACE("currentPos[%d]", _currentPosIndex);
     1428        for (int i = 0; i < _width * _height * 3; i += 3)
     1429            TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
     1430        TRACE("\n");
     1431        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1432    }
     1433    */
     1434
     1435    // compute distance
     1436    swap(_currentSortIndex, _destSortIndex);
     1437
     1438    // END - COMPUTE DISTANCE
     1439    ///////////////////////////////////////////////////////////
     1440
     1441    ///////////////////////////////////////////////////////////
     1442    // BEGIN - MERGE SORT
     1443    _currentSortPass = 0;
     1444
     1445    int logdSize = logd(_particleMaxCount);
     1446    _maxSortPasses = (logdSize + 1) * logdSize / 2;
     1447
     1448    _sortBegin = _sortEnd;
     1449    _sortEnd = (_sortBegin + _sortPassesPerFrame) % _maxSortPasses;
     1450
     1451    cgGLSetParameter2f(_srSizeParam, (float)_width, (float)_height);
     1452    cgGLSetParameter2f(_seSizeParam, (float)_width, (float)_height);
     1453
     1454    mergeSort(this->_particleMaxCount);
     1455
     1456    // _DEBUG
     1457    /*
     1458    {
     1459        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_currentSortIndex]);
     1460        static float debug[256];
     1461        glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
     1462        TRACE("\n");
     1463        TRACE("[%d]", _currentSortIndex);
     1464        for (int i = 0; i < _width * _height * 3; i += 3)
     1465            TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
     1466        TRACE("\n");
     1467        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1468    }
     1469    */
     1470
     1471    // END - MERGE SORT
     1472    ///////////////////////////////////////////////////////////
     1473
     1474    ///////////////////////////////////////////////////////////
     1475    // POSITION LOOKUP
     1476    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
     1477    cgGLBindProgram(_distanceSortLookupFP);
     1478    cgGLEnableProfile(CG_PROFILE_FP30);
     1479
     1480    glActiveTextureARB(GL_TEXTURE0_ARB);
     1481    glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[_currentSortIndex]);
     1482
     1483    glActiveTextureARB(GL_TEXTURE1_ARB);
     1484    glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
     1485
     1486    glPushAttrib(GL_VIEWPORT_BIT);
     1487    glViewport(0, 0, _width, _height);
     1488    glMatrixMode(GL_PROJECTION);
     1489    glPushMatrix();
     1490    glLoadIdentity();
     1491    glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     1492    glMatrixMode(GL_MODELVIEW);
     1493    glPushMatrix();
     1494    glLoadIdentity();
     1495
     1496    drawQuad();
     1497
     1498    glMatrixMode(GL_PROJECTION);
     1499    glPopMatrix();
     1500    glMatrixMode(GL_MODELVIEW);
     1501    glPopMatrix();
     1502    glPopAttrib();
     1503
     1504    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1505    cgGLDisableProfile(CG_PROFILE_FP30);
     1506
     1507    // POSITION LOOKUP
     1508    ///////////////////////////////////////////////////////////
     1509    glActiveTextureARB(GL_TEXTURE1_ARB);
     1510    glDisable(GL_TEXTURE_RECTANGLE_NV);
     1511
     1512    glActiveTextureARB(GL_TEXTURE0_ARB);
     1513    glDisable(GL_TEXTURE_RECTANGLE_NV);
     1514
     1515    // _DEBUG
     1516    /*
     1517    {
     1518        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
     1519        static float debug[256];
     1520        glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
     1521        TRACE("\n");
     1522        TRACE("[%d]", _currentSortIndex);
     1523        for (int i = 0; i < _width * _height * 3; i += 3)
     1524            TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
     1525        TRACE("\n");
     1526        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1527    }
     1528    */
     1529}
     1530
     1531void ParticleSystem::mergeSort(int count)
     1532{
     1533    if (count > 1) {
     1534        mergeSort(count >> 1);
     1535        merge(count, 1);
     1536    }
     1537}
     1538
     1539void ParticleSystem::merge(int count, int step)
     1540{
     1541    if (count > 2) {
     1542        merge(count >> 1, step << 1);
     1543
     1544        ++_currentSortPass;
     1545
     1546        if (_sortBegin < _sortEnd) {
     1547            if (_currentSortPass < _sortBegin || _currentSortPass >= _sortEnd)
     1548                return;
     1549        } else {
     1550            if (_currentSortPass < _sortBegin && _currentSortPass >= _sortEnd)
     1551                return;
     1552        }
     1553
     1554        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
     1555        cgGLBindProgram(_sortRecursionFP);
     1556        cgGLEnableProfile(CG_PROFILE_FP30);
     1557
     1558        glActiveTextureARB(GL_TEXTURE0_ARB);
     1559        glBindTexture(GL_TEXTURE_RECTANGLE_NV , sort_tex[_currentSortIndex]);
     1560
     1561        cgGLSetParameter1f(_srStepParam, (float)step);
     1562        cgGLSetParameter1f(_srCountParam, (float)count);
     1563
     1564        glPushAttrib(GL_VIEWPORT_BIT);
     1565        glViewport(0, 0, _width, _height);
     1566        glMatrixMode(GL_PROJECTION);
     1567        glPushMatrix();
     1568        glLoadIdentity();
     1569        glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     1570        glMatrixMode(GL_MODELVIEW);
     1571        glPushMatrix();
     1572        glLoadIdentity();
     1573
     1574        drawQuad();
     1575
     1576        glMatrixMode(GL_PROJECTION);
     1577        glPopMatrix();
     1578        glMatrixMode(GL_MODELVIEW);
     1579        glPopMatrix();
     1580        glPopAttrib();
     1581
     1582        cgGLDisableProfile(CG_PROFILE_FP30);
     1583
     1584        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1585        glBindTexture(GL_TEXTURE_RECTANGLE_NV , 0);
     1586    } else {
     1587        _currentSortPass++;
     1588
     1589        if (_sortBegin < _sortEnd) {
     1590            if (_currentSortPass < _sortBegin || _currentSortPass >= _sortEnd)
     1591                return;
     1592        } else {
     1593            if (_currentSortPass < _sortBegin && _currentSortPass >= _sortEnd)
     1594                return;
     1595        }
     1596
     1597        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
     1598        cgGLBindProgram(_sortEndFP);
     1599        cgGLEnableProfile(CG_PROFILE_FP30);
     1600
     1601        glActiveTextureARB(GL_TEXTURE0_ARB);
     1602        glBindTexture(GL_TEXTURE_RECTANGLE_NV , sort_tex[_currentSortIndex]);
     1603
     1604        cgGLSetParameter1f(_seStepParam, (float)step);
     1605
     1606        glPushAttrib(GL_VIEWPORT_BIT);
     1607        glViewport(0, 0, _width, _height);
     1608        glMatrixMode(GL_PROJECTION);
     1609        glPushMatrix();
     1610        glLoadIdentity();
     1611        glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
     1612        glMatrixMode(GL_MODELVIEW);
     1613        glPushMatrix();
     1614        glLoadIdentity();
     1615
     1616        drawQuad();
     1617
     1618        glMatrixMode(GL_PROJECTION);
     1619        glPopMatrix();
     1620        glMatrixMode(GL_MODELVIEW);
     1621        glPopMatrix();
     1622        glPopAttrib();
     1623
     1624        cgGLDisableProfile(CG_PROFILE_FP30);
     1625
     1626        glBindTexture(GL_TEXTURE_RECTANGLE_NV , 0);
     1627        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1628    }
     1629
     1630    swap(_currentSortIndex, _destSortIndex);
     1631}
     1632
     1633void ParticleSystem::renderStreamlines()
     1634{
     1635    if (_currentStreamlineIndex > 2) {
     1636        glPushMatrix();
     1637        glScalef(_scalex, _scaley, _scalez);
     1638        glTranslatef(-0.5f, -0.5f, -0.5f);
     1639
     1640        if (_drawBBoxEnabled) drawUnitBox();
     1641
     1642        glColor3f(1.0f, 0.0f, 0.0f);
     1643        glEnableClientState(GL_VERTEX_ARRAY);
     1644        //glEnableClientState(GL_COLOR_ARRAY);
     1645
     1646        _streamVertices->SetPointer(0);
     1647        //glColorPointer(4, GL_FLOAT, 0, 0);
     1648
     1649        ::glDrawElements(GL_LINES, _particleCount * 2 * (_currentStreamlineIndex - 1), GL_UNSIGNED_INT, _indexBuffer);
     1650        glDisableClientState(GL_VERTEX_ARRAY);
     1651        glPopMatrix();
     1652    }
     1653}
     1654
     1655void ParticleSystem::render()
     1656{
     1657    glPushMatrix();
     1658
     1659    if (_streamlineEnabled) {
     1660        renderStreamlines();
     1661    } else {
     1662        glScalef(_scalex, _scaley, _scalez);
     1663        glTranslatef(-0.5f, -0.5f, -0.5f);
     1664        if (_glypEnabled) {
     1665            if (_drawBBoxEnabled) drawUnitBox();
     1666            glColor3f(1, 1, 1);
     1667            glDepthMask(GL_FALSE);
     1668            glEnable(GL_BLEND);
     1669
     1670#ifndef USE_RGBA_ARROW
     1671            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    11851672#else
    1186                 cgGLSetParameter1f(_mpTimeScale, 0.005);
    1187                 //cgGLSetParameter1f(_mpTimeScale, 0.5);
    1188 
     1673            glEnable(GL_ALPHA_TEST);
     1674            //glAlphaFunc(GL_GEQUAL, 0.5);
     1675            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    11891676#endif
    1190                 //cgGLSetParameter1f(_mpTimeScale, 0.1);
    1191 
    1192                 //////////////////////////////////////////////////////
    1193                 // UPDATE POS
    1194                 cgGLSetTextureParameter(_mpVectorField, _curVectorFieldID);
    1195                 cgGLEnableTextureParameter(_mpVectorField);
    1196                 cgGLSetParameter3f(_mpScale, _scalex, _scaley, _scalez);
    1197                 cgGLSetParameter1f(_mpMaxScale, _maxVelocityScale);
    1198                 for (int i = 0; i < _stepSizeStreamline; ++i)
    1199                 {
    1200                         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
    1201                         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    1202                         glActiveTextureARB(GL_TEXTURE0_ARB);
    1203                         glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
    1204                         glActiveTextureARB(GL_TEXTURE1_ARB);
    1205                         glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
    1206                         drawQuad();
    1207                         swap(_currentPosIndex, _destPosIndex);
    1208                 }
    1209                 cgGLDisableTextureParameter(_mpVectorField);
    1210 
    1211                 glActiveTextureARB(GL_TEXTURE1_ARB);
    1212                 glDisable(GL_TEXTURE_RECTANGLE_NV);
    1213                 glActiveTextureARB(GL_TEXTURE0_ARB);
    1214                 glDisable(GL_TEXTURE_RECTANGLE_NV);
    1215 
    1216                 glDisable(GL_TEXTURE_RECTANGLE_NV);
    1217                 cgGLDisableProfile(CG_PROFILE_FP30);
    1218            
    1219                 glMatrixMode(GL_PROJECTION);
    1220                 glPopMatrix();
    1221                 glMatrixMode(GL_MODELVIEW);
    1222                 glPopMatrix();
    1223                 glPopAttrib();
    1224                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1225 
    1226                 if (_sortEnabled)
    1227                 {
    1228                         sort();
    1229 
    1230                         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
    1231                         _vertices->Read(_width, _height);
    1232                         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1233                 }
    1234                 else
    1235                 {
    1236                         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
    1237                         _vertices->Read(_width, _height);
    1238                         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1239                 }
    1240 
    1241 
    1242                 // NEW PARTICLES
    1243                 for (unsigned int i = 0; i < _emitters.size(); ++i)
    1244                 {
    1245                         // TBD..
    1246                         unsigned int numOfNewParticles = randomRange(_emitters[i]->_minNumOfNewParticles, _emitters[i]->_maxNumOfNewParticles) * deltaT;
    1247                         for (unsigned int k = 0; k < numOfNewParticles; ++k)
    1248                         {
    1249                                 float3 position = _emitters[i]->_position;
    1250                                 position += _emitters[i]->_maxPositionOffset *
    1251                                         float3(randomRange(-1.0f, 1.0f), randomRange(-1.0f, 1.0f), randomRange(-1.0f, 1.0f));
    1252 
    1253 
    1254                                 float lifetime = randomRange(_emitters[i]->_minLifeTime, _emitters[i]->_maxLifeTime);
    1255 
    1256                                 // TBD..
    1257                                 allocateParticle(position, float3(0.0f, 0.0f, 0.0f),  lifetime, 1 - (float) k / numOfNewParticles);
    1258                         }
    1259                 }
    1260 
    1261                
    1262                 initNewParticles();
    1263                
    1264                 _currentTime += deltaT;
    1265 
    1266                 cleanUpParticles();
    1267         }
    1268        
    1269         return true;
    1270 }
    1271 
    1272 void ParticleSystem::allocateParticle(const float3& position, const float3& velocity, float lifeTime, float initTimeStep)
    1273 {
    1274         if (_availableIndices.empty())
    1275         {
    1276                 return;
    1277         }
    1278 
    1279         int index = _availableIndices.top();
    1280         _availableIndices.pop();
    1281        
    1282         ActiveParticle p;
    1283         p.index = index;
    1284         p.timeOfDeath = _currentTime + lifeTime;
    1285         _activeParticles.push(p);
    1286 
    1287         NewParticle newParticle;
    1288         newParticle.index = index;
    1289         newParticle.position = position;
    1290         newParticle.velocity = velocity;
    1291         newParticle.timeOfDeath = p.timeOfDeath;
    1292         newParticle.initTimeStep = initTimeStep;
    1293 
    1294         _newParticles.push_back(newParticle);
    1295 
    1296         _particles[index].timeOfBirth = _currentTime;
    1297         _particles[index].lifeTime = lifeTime;
    1298 }
    1299 
    1300 void ParticleSystem::initNewParticles()
    1301 {
    1302         /////////////////////////////
    1303         // INIT NEW PARTICLE
    1304         glBindBufferARB(GL_ARRAY_BUFFER_ARB, _particleInfoBufferID);
    1305         Particle* pinfo = (Particle*) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY_ARB);
    1306 
    1307         std::vector<NewParticle>::iterator iter;
    1308         for (iter = _newParticles.begin(); iter != _newParticles.end(); ++iter)
    1309         {
    1310                 pinfo[iter->index] = _particles[iter->index];
    1311         }
    1312        
    1313         glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
    1314 
    1315         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
    1316        
    1317         glPushAttrib(GL_VIEWPORT_BIT);
    1318         glViewport(0, 0, _width, _height);
    1319         glMatrixMode(GL_PROJECTION);
    1320         glPushMatrix();
    1321         glLoadIdentity();
    1322         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1323         glMatrixMode(GL_MODELVIEW);
    1324         glPushMatrix();
    1325         glLoadIdentity();
    1326 
    1327         cgGLBindProgram(_initParticlePosFP);
    1328         cgGLEnableProfile(CG_PROFILE_FP30);
    1329         cgGLSetTextureParameter(_ipVectorFieldParam, _curVectorFieldID);
    1330         cgGLEnableTextureParameter(_ipVectorFieldParam);
    1331         // TBD..
    1332         //glActiveTextureARB(GL_TEXTURE0_ARB);
    1333         //VelocityPBuffers[VelocityCurrent]->Bind();
    1334 
    1335         glActiveTextureARB(GL_TEXTURE0_ARB);
    1336         glEnable(GL_TEXTURE_RECTANGLE_NV);
    1337         glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_destPosIndex]);
    1338 
    1339         glBegin(GL_POINTS);
    1340         for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++)
    1341         {
    1342             //TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
    1343                 glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
    1344                
    1345                 // TBD..
    1346                 //glMultiTexCoord2f(GL_TEXTURE1_ARB, (float)(i->Index % Width), (float)(i->Index / Height));
    1347                 //glMultiTexCoord1f(GL_TEXTURE2_ARB, iter->initTimeStep);
    1348                
    1349                 glVertex2f(     (float)(iter->index % _width),
    1350                         (float)(iter->index / _height) + 1/* + offsetY*/ /* + offsetY shouldn't be */);
    1351                 //TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
    1352         }
    1353         glEnd();
    1354 
    1355         glDisable(GL_TEXTURE_RECTANGLE_NV);
    1356         cgGLDisableTextureParameter(_ipVectorFieldParam);
    1357         cgGLDisableProfile(CG_PROFILE_FP30);
    1358        
    1359         glMatrixMode(GL_PROJECTION);
    1360         glPopMatrix();
    1361         glMatrixMode(GL_MODELVIEW);
    1362         glPopMatrix();
    1363         glPopAttrib();
    1364 
    1365         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1366 
    1367        
    1368         // INIT NEW END
    1369         /////////////////////////////
    1370 #if 1
    1371         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, _initPos_fbo);
    1372         glPushAttrib(GL_VIEWPORT_BIT);
    1373         glViewport(0, 0, _width, _height);
    1374         glMatrixMode(GL_PROJECTION);
    1375         glPushMatrix();
    1376         glLoadIdentity();
    1377         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1378         glMatrixMode(GL_MODELVIEW);
    1379         glPushMatrix();
    1380         glLoadIdentity();
    1381 
    1382         cgGLBindProgram(_initParticlePosFP);
    1383         cgGLEnableProfile(CG_PROFILE_FP30);
    1384         cgGLSetTextureParameter(_ipVectorFieldParam, _curVectorFieldID);
    1385         cgGLEnableTextureParameter(_ipVectorFieldParam);
    1386         // TBD..
    1387         //glActiveTextureARB(GL_TEXTURE0_ARB);
    1388         //VelocityPBuffers[VelocityCurrent]->Bind();
    1389 
    1390         glActiveTextureARB(GL_TEXTURE0_ARB);
    1391         glEnable(GL_TEXTURE_RECTANGLE_NV);
    1392         //glBindTexture(GL_TEXTURE_RECTANGLE_NV, _initPosTex);
    1393         glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_destPosIndex]);
    1394 
    1395         glBegin(GL_POINTS);
    1396         for (iter = _newParticles.begin(); iter != _newParticles.end(); iter++)
    1397         {
    1398                 //TRACE("[%d] %f %f %f\n", iter->index, iter->position.x,iter->position.y,iter->position.z);
    1399                 glMultiTexCoord3f(GL_TEXTURE0, iter->position.x,iter->position.y,iter->position.z);
    1400                
    1401                 // TBD..
    1402                 //glMultiTexCoord2f(GL_TEXTURE1_ARB, (float)(i->Index % Width), (float)(i->Index / Height));
    1403                 //glMultiTexCoord1f(GL_TEXTURE2_ARB, iter->initTimeStep);
    1404                
    1405                 glVertex2f(     (float)(iter->index % _width),
    1406                         (float)(iter->index / _height) + 1/* + offsetY*/ /* + offsetY shouldn't be */);
    1407                 //TRACE("%f %f\n", (float) (iter->index % _width), (float)(iter->index / _width));
    1408         }
    1409         glEnd();
    1410 
    1411         glDisable(GL_TEXTURE_RECTANGLE_NV);
    1412         cgGLDisableTextureParameter(_ipVectorFieldParam);
    1413         cgGLDisableProfile(CG_PROFILE_FP30);
    1414        
    1415         glMatrixMode(GL_PROJECTION);
    1416         glPopMatrix();
    1417         glMatrixMode(GL_MODELVIEW);
    1418         glPopMatrix();
    1419         glPopAttrib();
    1420 
    1421         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
     1677            glEnable(GL_POINT_SPRITE_NV);
     1678            glPointSize(_pointSize);
     1679
     1680            glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
     1681
     1682#ifndef TEST
     1683            _arrows->bind(0);
     1684            glEnable(GL_TEXTURE_2D);
     1685            //glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
     1686            glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
     1687
     1688            glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
     1689            glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
     1690            glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
     1691
     1692            cgGLBindProgram(_particleVP);
     1693            cgGLBindProgram(_particleFP);
     1694            cgGLEnableProfile(CG_PROFILE_VP40);
     1695            cgGLEnableProfile(CG_PROFILE_FP40);
     1696
     1697            cgSetParameter1f(_mvCurrentTimeParam, _currentTime);
     1698            //TRACE("%f %f, %f %d\n", _fov, tan(_fov), tan(_fov / 2.0), _screenHeight);
     1699            //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5);
     1700            //float v = tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5;
     1701            cgSetParameter1f(_mvTanHalfFOVParam, tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5);
     1702            //cgSetParameter1f(_mvTanHalfFOVParam,  _screenHeight * 0.5 / tan(_fov * PI / 180 * 0.5));
     1703
     1704            cgGLSetStateMatrixParameter(_mvpParticleParam,
     1705                                        CG_GL_MODELVIEW_PROJECTION_MATRIX,
     1706                                        CG_GL_MATRIX_IDENTITY);
     1707            cgGLSetStateMatrixParameter(_mvParticleParam,
     1708                                        CG_GL_MODELVIEW_MATRIX,
     1709                                        CG_GL_MATRIX_IDENTITY);
     1710
     1711            // TBD..
     1712            glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);                     
     1713            glEnableVertexAttribArrayARB(8);
     1714            glEnableClientState(GL_VERTEX_ARRAY);
     1715            //glEnableClientState(GL_COLOR_ARRAY);
     1716            _vertices->SetPointer(0);
     1717            //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
     1718            //glColorPointer(4, GL_FLOAT, 0, 0);
     1719            //glBindBufferARB(GL_ARRAY_BUFFER, 0);
     1720
     1721            // TBD...
     1722            glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
     1723            glPointSize(1);
     1724
     1725            glDisableClientState(GL_VERTEX_ARRAY);
     1726            //glDisableClientState(GL_COLOR_ARRAY);
     1727
     1728            // TBD...
     1729            ::glDisableVertexAttribArray(8);
     1730            glPopClientAttrib();
     1731
     1732            cgGLDisableProfile(CG_PROFILE_VP40);
     1733            cgGLDisableProfile(CG_PROFILE_FP40);
     1734
     1735
     1736            glDepthMask(GL_TRUE);
     1737
     1738            glDisable(GL_POINT_SPRITE_NV);
     1739            glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
     1740
     1741            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     1742            glDisable(GL_BLEND);
     1743#else
     1744            glBindTexture(GL_TEXTURE_2D, ::SpotTexID);
     1745            glEnable(GL_TEXTURE_2D);
     1746            //glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
     1747            glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
     1748
     1749            glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
     1750            glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
     1751            glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
     1752
     1753            glEnableClientState(GL_VERTEX_ARRAY);
     1754            //glEnableClientState(GL_COLOR_ARRAY);
     1755            _vertices->SetPointer(0);
     1756            //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
     1757            //glColorPointer(4, GL_FLOAT, 0, 0);
     1758            //glBindBufferARB(GL_ARRAY_BUFFER, 0);
     1759
     1760            // TBD...
     1761            glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
     1762            glPointSize(1);
     1763            glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
     1764
     1765            glDisableClientState(GL_VERTEX_ARRAY);
     1766
     1767            glDepthMask(GL_TRUE);
     1768
     1769            glDisable(GL_POINT_SPRITE_NV);
     1770            glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
     1771
     1772            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     1773            glDisable(GL_BLEND);
    14221774#endif
    1423 
    1424         // Free array.
    1425         _newParticles.clear();
    1426 }
    1427 
    1428 void ParticleSystem::cleanUpParticles()
    1429 {
    1430         if (! _activeParticles.empty())
    1431         {
    1432                 while (_activeParticles.top().timeOfDeath < _currentTime)
    1433                 {
    1434                         unsigned int i = _activeParticles.top().index;
    1435                         _activeParticles.pop();
    1436                         _availableIndices.push(i);
    1437                         //_usedIndices[i] = false;
    1438 
    1439                         //if (i >= _maxUsedIndex)
    1440                         //      while (!_usedIndices[_maxUsedIndex])
    1441                         //              _maxUsedIndex--;
    1442 
    1443                 }
    1444         }
    1445 }
    1446 
    1447 void ParticleSystem::sort()
    1448 {
    1449        
    1450         ///////////////////////////////////////////////////////////
    1451         // BEGIN - COMPUTE DISTANCE     
    1452         vrVector3f pos;
    1453         vrMatrix4x4f mat;
    1454         glPushMatrix();
    1455         glLoadIdentity();
    1456                 glScalef(_scalex, _scaley, _scalez);
    1457                 glTranslatef(-0.5f, -0.5f, -0.5f);
    1458                 glGetFloatv(GL_MODELVIEW_MATRIX, mat.get());
    1459         glPopMatrix();
    1460         mat.invert();
    1461         mat.getTranslation(pos);
    1462 
    1463         cgGLBindProgram(_distanceSortFP);
    1464         cgGLEnableProfile(CG_PROFILE_FP30);
    1465 
    1466         glActiveTextureARB(GL_TEXTURE0_ARB);
    1467         glEnable(GL_TEXTURE_RECTANGLE_NV);
    1468         glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[_currentSortIndex]);
    1469        
    1470         glActiveTextureARB(GL_TEXTURE1_ARB);
    1471         glEnable(GL_TEXTURE_RECTANGLE_NV);
    1472         glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
    1473 
    1474         cgGLSetParameter3f(_viewPosParam, pos.x, pos.y, pos.z);
    1475 
    1476         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
    1477         glPushAttrib(GL_VIEWPORT_BIT);
    1478         glViewport(0, 0, _width, _height);
    1479         glMatrixMode(GL_PROJECTION);
    1480         glPushMatrix();
    1481         glLoadIdentity();
    1482         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1483         glMatrixMode(GL_MODELVIEW);
    1484         glPushMatrix();
    1485         glLoadIdentity();
    1486 
    1487         drawQuad();
    1488 
    1489         cgGLDisableProfile(CG_PROFILE_FP30);
    1490 
    1491         glMatrixMode(GL_PROJECTION);
    1492         glPopMatrix();
    1493         glMatrixMode(GL_MODELVIEW);
    1494         glPopMatrix();
    1495         glPopAttrib();
    1496         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1497 
    1498         ///////////////////////////////
    1499         // _DEBUG
    1500         /*
    1501         {
    1502         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
    1503         static float debug[256];
    1504         glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
    1505         TRACE("[%d]", _currentSortIndex);
    1506         for (int i = 0; i < _width * _height * 3; i += 3)
    1507                 TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1508         TRACE("\n");
    1509         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1510        
    1511         }
    1512         */
    1513         ///////////////////////////////
    1514         // _DEBUG
    1515         /*
    1516         {
    1517                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_currentPosIndex]);
    1518                 static float debug[256];
    1519                 glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
    1520                 TRACE("\n");
    1521                 TRACE("currentPos[%d]", _currentPosIndex);
    1522                 for (int i = 0; i < _width * _height * 3; i += 3)
    1523                         TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1524                         TRACE("\n");
    1525                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1526         }
    1527         */
    1528        
    1529        
    1530         ///////////////////////////////////////////////////////////
    1531 
    1532 
    1533         // compute distance
    1534         swap(_currentSortIndex, _destSortIndex);
    1535 
    1536         // END - COMPUTE DISTANCE
    1537         ///////////////////////////////////////////////////////////
    1538        
    1539         ///////////////////////////////////////////////////////////
    1540         // BEGIN - MERGE SORT
    1541         _currentSortPass = 0;
    1542 
    1543         int logdSize = logd(_particleMaxCount);
    1544         _maxSortPasses = (logdSize + 1) * logdSize / 2;
    1545 
    1546         _sortBegin = _sortEnd;
    1547         _sortEnd = (_sortBegin + _sortPassesPerFrame) % _maxSortPasses;
    1548 
    1549         cgGLSetParameter2f(_srSizeParam, (float)_width, (float)_height);
    1550         cgGLSetParameter2f(_seSizeParam, (float)_width, (float)_height);
    1551 
    1552         mergeSort(this->_particleMaxCount);
    1553 
    1554         ///////////////////////////////
    1555         // _DEBUG
    1556         /*
    1557         {
    1558                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_currentSortIndex]);
    1559                 static float debug[256];
    1560                 glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
    1561                 TRACE("\n");
    1562                 TRACE("[%d]", _currentSortIndex);
    1563                 for (int i = 0; i < _width * _height * 3; i += 3)
    1564                 TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1565                 TRACE("\n");
    1566                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1567         }
    1568         */
    1569        
    1570         ///////////////////////////////////////////////////////////
    1571 
    1572 
    1573        
    1574         // END - MERGE SORT
    1575         ///////////////////////////////////////////////////////////
    1576 
    1577         ///////////////////////////////////////////////////////////
    1578         // POSITION LOOKUP
    1579         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
    1580         cgGLBindProgram(_distanceSortLookupFP);
    1581         cgGLEnableProfile(CG_PROFILE_FP30);
    1582 
    1583         glActiveTextureARB(GL_TEXTURE0_ARB);
    1584         glBindTexture(GL_TEXTURE_RECTANGLE_NV, sort_tex[_currentSortIndex]);
    1585        
    1586         glActiveTextureARB(GL_TEXTURE1_ARB);
    1587         glBindTexture(GL_TEXTURE_RECTANGLE_NV, psys_tex[_currentPosIndex]);
    1588 
    1589         glPushAttrib(GL_VIEWPORT_BIT);
    1590         glViewport(0, 0, _width, _height);
    1591         glMatrixMode(GL_PROJECTION);
    1592         glPushMatrix();
    1593         glLoadIdentity();
    1594         glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1595         glMatrixMode(GL_MODELVIEW);
    1596         glPushMatrix();
    1597         glLoadIdentity();
    1598 
    1599         drawQuad();
    1600 
    1601         glMatrixMode(GL_PROJECTION);
    1602         glPopMatrix();
    1603         glMatrixMode(GL_MODELVIEW);
    1604         glPopMatrix();
    1605         glPopAttrib();
    1606 
    1607         glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1608         cgGLDisableProfile(CG_PROFILE_FP30);
    1609        
    1610         // POSITION LOOKUP
    1611         ///////////////////////////////////////////////////////////
    1612         glActiveTextureARB(GL_TEXTURE1_ARB);
    1613         glDisable(GL_TEXTURE_RECTANGLE_NV);
    1614 
    1615         glActiveTextureARB(GL_TEXTURE0_ARB);
    1616         glDisable(GL_TEXTURE_RECTANGLE_NV);
    1617 
    1618         ///////////////////////////////
    1619         // _DEBUG
    1620         /*
    1621         {
    1622                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, psys_fbo[_destPosIndex]);
    1623                 static float debug[256];
    1624                 glReadPixels(0, 0, _width, _height, GL_RGB, GL_FLOAT, (float*)debug);
    1625                 TRACE("\n");
    1626                 TRACE("[%d]", _currentSortIndex);
    1627                 for (int i = 0; i < _width * _height * 3; i += 3)
    1628                 TRACE("%.2f, %.2f, %.2f\n", debug[i], debug[i+1], debug[i+2]);
    1629                 TRACE("\n");
    1630                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1631         }
    1632         */
    1633        
    1634 }
    1635 
    1636 void ParticleSystem::mergeSort(int count)
    1637 {
    1638         if (count > 1)
    1639         {
    1640                 mergeSort(count >> 1);
    1641                 merge(count, 1);
    1642         }
    1643 }
    1644 
    1645 void ParticleSystem::merge(int count, int step)
    1646 {
    1647         if (count > 2)
    1648         {
    1649                 merge(count >> 1, step << 1);
    1650 
    1651                 ++_currentSortPass;
    1652 
    1653                 if (_sortBegin < _sortEnd)
    1654                 {       
    1655                         if (_currentSortPass < _sortBegin || _currentSortPass >= _sortEnd)
    1656                                 return;
    1657                 }
    1658                 else
    1659                 {
    1660                         if (_currentSortPass < _sortBegin && _currentSortPass >= _sortEnd)
    1661                                 return;
    1662                 }
    1663 
    1664                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
    1665                 cgGLBindProgram(_sortRecursionFP);
    1666                 cgGLEnableProfile(CG_PROFILE_FP30);
    1667 
    1668                 glActiveTextureARB(GL_TEXTURE0_ARB);
    1669                 glBindTexture(GL_TEXTURE_RECTANGLE_NV , sort_tex[_currentSortIndex]);
    1670 
    1671                 cgGLSetParameter1f(_srStepParam, (float)step);
    1672                 cgGLSetParameter1f(_srCountParam, (float)count);
    1673 
    1674                 glPushAttrib(GL_VIEWPORT_BIT);
    1675                 glViewport(0, 0, _width, _height);
    1676                 glMatrixMode(GL_PROJECTION);
    1677                 glPushMatrix();
    1678                 glLoadIdentity();
    1679                 glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1680                 glMatrixMode(GL_MODELVIEW);
    1681                 glPushMatrix();
    1682                 glLoadIdentity();
    1683 
    1684                 drawQuad();
    1685 
    1686                 glMatrixMode(GL_PROJECTION);
    1687                 glPopMatrix();
    1688                 glMatrixMode(GL_MODELVIEW);
    1689                 glPopMatrix();
    1690                 glPopAttrib();
    1691 
    1692                 cgGLDisableProfile(CG_PROFILE_FP30);
    1693 
    1694                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1695                 glBindTexture(GL_TEXTURE_RECTANGLE_NV , 0);
    1696         }
    1697         else
    1698         {
    1699                 _currentSortPass++;
    1700 
    1701                 if (_sortBegin < _sortEnd)
    1702                 {
    1703                         if (_currentSortPass < _sortBegin || _currentSortPass >= _sortEnd)
    1704                                 return;
    1705                 }
    1706                 else
    1707                 {
    1708                         if (_currentSortPass < _sortBegin && _currentSortPass >= _sortEnd)
    1709                                 return;
    1710                 }
    1711 
    1712                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, sort_fbo[_destSortIndex]);
    1713                 cgGLBindProgram(_sortEndFP);
    1714                 cgGLEnableProfile(CG_PROFILE_FP30);
    1715 
    1716                 glActiveTextureARB(GL_TEXTURE0_ARB);
    1717                 glBindTexture(GL_TEXTURE_RECTANGLE_NV , sort_tex[_currentSortIndex]);
    1718 
    1719                 cgGLSetParameter1f(_seStepParam, (float)step);
    1720 
    1721                 glPushAttrib(GL_VIEWPORT_BIT);
    1722                 glViewport(0, 0, _width, _height);
    1723                 glMatrixMode(GL_PROJECTION);
    1724                 glPushMatrix();
    1725                 glLoadIdentity();
    1726                 glOrtho(0, _width, 0, _height, -10.0f, 10.0f);
    1727                 glMatrixMode(GL_MODELVIEW);
    1728                 glPushMatrix();
    1729                 glLoadIdentity();
    1730 
    1731                 drawQuad();
    1732 
    1733                 glMatrixMode(GL_PROJECTION);
    1734                 glPopMatrix();
    1735                 glMatrixMode(GL_MODELVIEW);
    1736                 glPopMatrix();
    1737                 glPopAttrib();
    1738 
    1739                 cgGLDisableProfile(CG_PROFILE_FP30);
    1740 
    1741                 glBindTexture(GL_TEXTURE_RECTANGLE_NV , 0);
    1742                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    1743         }
    1744 
    1745         swap(_currentSortIndex, _destSortIndex);
    1746 }
    1747 
    1748 void ParticleSystem::renderStreamlines()
    1749 {
    1750         //return;
    1751         if (_currentStreamlineIndex > 2)
    1752         {
    1753                 glPushMatrix();
    1754                 glScalef(_scalex, _scaley, _scalez);
    1755                 glTranslatef(-0.5f, -0.5f, -0.5f);
    1756 
    1757                 if (_drawBBoxEnabled) drawUnitBox();
    1758 
    1759                 glColor3f(1.0f, 0.0f, 0.0f);
    1760                 glEnableClientState(GL_VERTEX_ARRAY);
    1761                 //glEnableClientState(GL_COLOR_ARRAY);
    1762                
    1763                 _streamVertices->SetPointer(0);
    1764                 //glColorPointer(4, GL_FLOAT, 0, 0);
    1765                
    1766                 ::glDrawElements(GL_LINES, _particleCount * 2 * (_currentStreamlineIndex - 1), GL_UNSIGNED_INT, _indexBuffer);
    1767                 glDisableClientState(GL_VERTEX_ARRAY);
    1768                 glPopMatrix();
    1769         }
    1770 }
    1771 
    1772 void ParticleSystem::render()
    1773 {
    1774         glPushMatrix();
    1775 
    1776         if (_streamlineEnabled)
    1777         {
    1778                 renderStreamlines();
    1779         }
    1780         else {
    1781                 glScalef(_scalex, _scaley, _scalez);
    1782                 glTranslatef(-0.5f, -0.5f, -0.5f);
    1783                 if (_glypEnabled)
    1784                 {
    1785                        
    1786                         if (_drawBBoxEnabled) drawUnitBox();
    1787                         glColor3f(1, 1, 1);
    1788                         glDepthMask(GL_FALSE);
    1789                         glEnable(GL_BLEND);
    1790                        
    1791 #ifndef USE_RGBA_ARROW
    1792                         glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    1793 #else
    1794                         glEnable(GL_ALPHA_TEST);
    1795                         //glAlphaFunc(GL_GEQUAL, 0.5);
    1796                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     1775        } else {
     1776                if (_drawBBoxEnabled) drawUnitBox();
     1777
     1778                glColor3f(1, 1, 1);
     1779                glEnableClientState(GL_VERTEX_ARRAY);
     1780                //glEnableClientState(GL_COLOR_ARRAY);
     1781                glPointSize(10);
     1782                _vertices->SetPointer(0);
     1783                //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
     1784                //glColorPointer(4, GL_FLOAT, 0, 0);
     1785                //glBindBufferARB(GL_ARRAY_BUFFER, 0);
     1786                glDrawArrays(GL_POINTS, 0, _particleMaxCount);
     1787
     1788                glPointSize(1);
     1789                _vertices->SetPointer(0);
     1790                //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
     1791                //glColorPointer(4, GL_FLOAT, 0, 0);
     1792                //glBindBufferARB(GL_ARRAY_BUFFER, 0);
     1793                glDrawArrays(GL_POINTS, 0, _particleMaxCount);
     1794
     1795                glDisableClientState(GL_VERTEX_ARRAY);
     1796        }
     1797
     1798#ifdef notdef
     1799        if (_criticalPoints && _criticalPoints->size()) {
     1800            std::vector<vrVector3f>::iterator iter;
     1801            glColor4f(1, 1, 1, 1);
     1802            glPointSize(10);
     1803            glBegin(GL_POINTS);
     1804            for (iter = _criticalPoints->begin(); iter != _criticalPoints->end(); ++iter) {
     1805                glVertex3f((*iter).x, (*iter).y, (*iter).z);           
     1806            }
     1807            glEnd();
     1808            glPointSize(1);
     1809        }
    17971810#endif
    1798                         glEnable(GL_POINT_SPRITE_NV);
    1799                         glPointSize(_pointSize);
    1800                                
    1801                         glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
    1802 
    1803 #ifndef TEST
    1804                         _arrows->bind(0);
    1805                         glEnable(GL_TEXTURE_2D);
    1806                         //glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
    1807                         glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
    1808 
    1809                         glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
    1810                         glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
    1811                         glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
    1812 
    1813                         cgGLBindProgram(_particleVP);
    1814                         cgGLBindProgram(_particleFP);
    1815                         cgGLEnableProfile(CG_PROFILE_VP40);
    1816                         cgGLEnableProfile(CG_PROFILE_FP40);
    1817 
    1818 
    1819                         cgSetParameter1f(_mvCurrentTimeParam, _currentTime);
    1820                         //TRACE("%f %f, %f %d\n", _fov, tan(_fov), tan(_fov / 2.0), _screenHeight);
    1821                         //cgSetParameter1f(_mvTanHalfFOVParam, -tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5);
    1822                         //float v = tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5;
    1823                         cgSetParameter1f(_mvTanHalfFOVParam, tan(_fov * PI / 180 * 0.5) * _screenHeight * 0.5);
    1824                         //cgSetParameter1f(_mvTanHalfFOVParam,  _screenHeight * 0.5 / tan(_fov * PI / 180 * 0.5));
    1825                        
    1826                         cgGLSetStateMatrixParameter(_mvpParticleParam,
    1827                                                         CG_GL_MODELVIEW_PROJECTION_MATRIX,
    1828                                                         CG_GL_MATRIX_IDENTITY);
    1829                         cgGLSetStateMatrixParameter(_mvParticleParam,
    1830                                                         CG_GL_MODELVIEW_MATRIX,
    1831                                                         CG_GL_MATRIX_IDENTITY);
    1832 
    1833                        
    1834 
    1835                
    1836                
    1837                         // TBD..
    1838                         glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);                 
    1839                         glEnableVertexAttribArrayARB(8);
    1840                         glEnableClientState(GL_VERTEX_ARRAY);
    1841                         //glEnableClientState(GL_COLOR_ARRAY);
    1842                         _vertices->SetPointer(0);
    1843                         //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
    1844                         //glColorPointer(4, GL_FLOAT, 0, 0);
    1845                         //glBindBufferARB(GL_ARRAY_BUFFER, 0);
    1846 
    1847                         // TBD...
    1848                         glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
    1849                         glPointSize(1);
    1850        
    1851 
    1852                         glDisableClientState(GL_VERTEX_ARRAY);
    1853                         //glDisableClientState(GL_COLOR_ARRAY);
    1854                        
    1855                         // TBD...
    1856                         ::glDisableVertexAttribArray(8);
    1857                         glPopClientAttrib();
    1858                        
    1859                         cgGLDisableProfile(CG_PROFILE_VP40);
    1860                         cgGLDisableProfile(CG_PROFILE_FP40);
    1861 
    1862                        
    1863                        
    1864                         glDepthMask(GL_TRUE);
    1865                        
    1866                         glDisable(GL_POINT_SPRITE_NV);
    1867                         glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
    1868 
    1869                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    1870                         glDisable(GL_BLEND);
    1871 #else
    1872                         glBindTexture(GL_TEXTURE_2D, ::SpotTexID);
    1873                         glEnable(GL_TEXTURE_2D);
    1874                         //glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f );
    1875                         glPointParameterfARB( GL_POINT_FADE_THRESHOLD_SIZE_ARB, 0.0f );
    1876 
    1877                         glPointParameterfARB( GL_POINT_SIZE_MIN_ARB, 1.0f);
    1878                         glPointParameterfARB( GL_POINT_SIZE_MAX_ARB, 100.0f);
    1879                         glTexEnvf( GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE );
    1880 
    1881                         glEnableClientState(GL_VERTEX_ARRAY);
    1882                         //glEnableClientState(GL_COLOR_ARRAY);
    1883                         _vertices->SetPointer(0);
    1884                         //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
    1885                         //glColorPointer(4, GL_FLOAT, 0, 0);
    1886                         //glBindBufferARB(GL_ARRAY_BUFFER, 0);
    1887 
    1888                         // TBD...
    1889                         glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
    1890                         glPointSize(1);
    1891                         glDrawArrays(GL_POINTS, 0, this->_particleMaxCount);
    1892        
    1893 
    1894                         glDisableClientState(GL_VERTEX_ARRAY);
    1895                        
    1896                        
    1897                         glDepthMask(GL_TRUE);
    1898                        
    1899                         glDisable(GL_POINT_SPRITE_NV);
    1900                         glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
    1901 
    1902                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    1903                         glDisable(GL_BLEND);
    1904 #endif
    1905                 }
    1906                 else
    1907                 {
    1908                        
    1909                         if (_drawBBoxEnabled) drawUnitBox();
    1910                        
    1911                        
    1912                
    1913                         glColor3f(1, 1, 1);
    1914                         glEnableClientState(GL_VERTEX_ARRAY);
    1915                         //glEnableClientState(GL_COLOR_ARRAY);
    1916                         glPointSize(10);
    1917                         _vertices->SetPointer(0);
    1918                         //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
    1919                         //glColorPointer(4, GL_FLOAT, 0, 0);
    1920                         //glBindBufferARB(GL_ARRAY_BUFFER, 0);
    1921                         glDrawArrays(GL_POINTS, 0, _particleMaxCount);
    1922 
    1923                         glPointSize(1);
    1924                         _vertices->SetPointer(0);
    1925                         //glBindBufferARB(GL_ARRAY_BUFFER, _colorBufferID);
    1926                         //glColorPointer(4, GL_FLOAT, 0, 0);
    1927                         //glBindBufferARB(GL_ARRAY_BUFFER, 0);
    1928                         glDrawArrays(GL_POINTS, 0, _particleMaxCount);
    1929 
    1930                         glDisableClientState(GL_VERTEX_ARRAY);
    1931                 }
    1932 
    1933                 /*if (_criticalPoints && _criticalPoints->size())
    1934                 {
    1935                         std::vector<vrVector3f>::iterator iter;
    1936                         glColor4f(1, 1, 1, 1);
    1937                         glPointSize(10);
    1938                         glBegin(GL_POINTS);
    1939                         for (iter = _criticalPoints->begin(); iter != _criticalPoints->end(); ++iter)
    1940                         {
    1941                                 glVertex3f((*iter).x, (*iter).y, (*iter).z);
    1942                                
    1943                         }
    1944                         glEnd();
    1945                         glPointSize(1);
    1946                 }
    1947                 */
    1948         }
    1949 
    1950         glPopMatrix();
     1811    }
     1812
     1813    glPopMatrix();
    19511814}
    19521815
    19531816void ParticleSystem::drawQuad(int x1, int y1, int x2, int y2)
    19541817{
    1955         glBegin(GL_QUADS);
    1956 
    1957         glTexCoord2f(x1, y1);
    1958         glVertex2f(x1, y1);
    1959 
    1960         glTexCoord2f(x2, y1);
    1961         glVertex2f(x2, y1);
    1962 
    1963         glTexCoord2f(x2, y2);
    1964         glVertex2f(x2, y2);
    1965 
    1966         glTexCoord2f(x1, y2);
    1967         glVertex2f(x1, y2);
    1968 
    1969         glEnd();
    1970 }
    1971 
    1972 
    1973 
     1818    glBegin(GL_QUADS);
     1819
     1820    glTexCoord2f(x1, y1);
     1821    glVertex2f(x1, y1);
     1822
     1823    glTexCoord2f(x2, y1);
     1824    glVertex2f(x2, y1);
     1825
     1826    glTexCoord2f(x2, y2);
     1827    glVertex2f(x2, y2);
     1828
     1829    glTexCoord2f(x1, y2);
     1830    glVertex2f(x1, y2);
     1831
     1832    glEnd();
     1833}
    19741834
    19751835void ParticleSystem::drawQuad()
    19761836{
    1977         glBegin(GL_QUADS);
    1978 
    1979         glTexCoord2f(0, 0);
    1980         glVertex2f(0, 0);
    1981 
    1982         glTexCoord2f((float)_width, 0);
    1983         glVertex2f((float)_width, 0);
    1984 
    1985         glTexCoord2f((float)_width, (float)_height);
    1986         glVertex2f((float)_width, (float)_height);
    1987 
    1988         glTexCoord2f(0, (float)_height);
    1989         glVertex2f(0, (float)_height);
    1990 
    1991         glEnd();
    1992 }
    1993 
    1994 
     1837    glBegin(GL_QUADS);
     1838
     1839    glTexCoord2f(0, 0);
     1840    glVertex2f(0, 0);
     1841
     1842    glTexCoord2f((float)_width, 0);
     1843    glVertex2f((float)_width, 0);
     1844
     1845    glTexCoord2f((float)_width, (float)_height);
     1846    glVertex2f((float)_width, (float)_height);
     1847
     1848    glTexCoord2f(0, (float)_height);
     1849    glVertex2f(0, (float)_height);
     1850
     1851    glEnd();
     1852}
    19951853
    19961854void ParticleSystem::addEmitter(ParticleEmitter* emitter)
    19971855{
    1998         _emitters.push_back(emitter);
     1856    _emitters.push_back(emitter);
    19991857}
    20001858
    20011859void ParticleSystem::removeEmitter(int index)
    20021860{
    2003         // TBD...
     1861    // TBD...
    20041862}
    20051863
    20061864void ParticleSystem::removeAllEmitters()
    20071865{
    2008         std::vector<ParticleEmitter*>::iterator iter;
    2009         for (iter = _emitters.begin(); iter != _emitters.end(); ++iter)
    2010         {
    2011                 delete *iter;
    2012         }
    2013         _emitters.clear();
     1866    std::vector<ParticleEmitter*>::iterator iter;
     1867    for (iter = _emitters.begin(); iter != _emitters.end(); ++iter) {
     1868        delete *iter;
     1869    }
     1870    _emitters.clear();
    20141871}
    20151872
    20161873void ParticleSystem::drawUnitBox()
    20171874{
    2018         float x0 = 0.0f, y0 = 0.0f, z0 = 0.0f;
    2019         float x1 = 1.0f, y1 = 1.0f, z1 = 1.0f;
    2020         float r = 1.0f, g = 1.0f, b = 0.0f;
    2021         float line_width = 2.0f;
    2022         glEnable(GL_DEPTH_TEST);
    2023         glDisable(GL_TEXTURE_2D);
    2024         glEnable(GL_BLEND);
    2025 
    2026         glColor4d(r, g, b, 1.0);
    2027         glLineWidth(line_width);
    2028 
    2029         glBegin(GL_LINE_LOOP);
    2030         {
    2031                 glVertex3d(x0, y0, z0);
    2032                 glVertex3d(x1, y0, z0);
    2033                 glVertex3d(x1, y1, z0);
    2034                 glVertex3d(x0, y1, z0);
    2035         }
    2036         glEnd();
    2037 
    2038         glBegin(GL_LINE_LOOP);
    2039         {
    2040                 glVertex3d(x0, y0, z1);
    2041                 glVertex3d(x1, y0, z1);
    2042                 glVertex3d(x1, y1, z1);
    2043                 glVertex3d(x0, y1, z1);
    2044         }
    2045         glEnd();
    2046 
    2047 
    2048         glBegin(GL_LINE_LOOP);
    2049         {
    2050                 glVertex3d(x0, y0, z0);
    2051                 glVertex3d(x0, y0, z1);
    2052                 glVertex3d(x0, y1, z1);
    2053                 glVertex3d(x0, y1, z0);
    2054         }
    2055         glEnd();
    2056 
    2057         glBegin(GL_LINE_LOOP);
    2058         {
    2059                 glVertex3d(x1, y0, z0);
    2060                 glVertex3d(x1, y0, z1);
    2061                 glVertex3d(x1, y1, z1);
    2062                 glVertex3d(x1, y1, z0);
    2063         }
    2064         glEnd();
    2065         glLineWidth(1.0f);
     1875    float x0 = 0.0f, y0 = 0.0f, z0 = 0.0f;
     1876    float x1 = 1.0f, y1 = 1.0f, z1 = 1.0f;
     1877    float r = 1.0f, g = 1.0f, b = 0.0f;
     1878    float line_width = 2.0f;
     1879    glEnable(GL_DEPTH_TEST);
     1880    glDisable(GL_TEXTURE_2D);
     1881    glEnable(GL_BLEND);
     1882
     1883    glColor4d(r, g, b, 1.0);
     1884    glLineWidth(line_width);
     1885
     1886    glBegin(GL_LINE_LOOP);
     1887    {
     1888        glVertex3d(x0, y0, z0);
     1889        glVertex3d(x1, y0, z0);
     1890        glVertex3d(x1, y1, z0);
     1891        glVertex3d(x0, y1, z0);
     1892    }
     1893    glEnd();
     1894
     1895    glBegin(GL_LINE_LOOP);
     1896    {
     1897        glVertex3d(x0, y0, z1);
     1898        glVertex3d(x1, y0, z1);
     1899        glVertex3d(x1, y1, z1);
     1900        glVertex3d(x0, y1, z1);
     1901    }
     1902    glEnd();
     1903
     1904    glBegin(GL_LINE_LOOP);
     1905    {
     1906        glVertex3d(x0, y0, z0);
     1907        glVertex3d(x0, y0, z1);
     1908        glVertex3d(x0, y1, z1);
     1909        glVertex3d(x0, y1, z0);
     1910    }
     1911    glEnd();
     1912
     1913    glBegin(GL_LINE_LOOP);
     1914    {
     1915        glVertex3d(x1, y0, z0);
     1916        glVertex3d(x1, y0, z1);
     1917        glVertex3d(x1, y1, z1);
     1918        glVertex3d(x1, y1, z0);
     1919    }
     1920    glEnd();
     1921    glLineWidth(1.0f);
    20661922}
    20671923
    20681924void ParticleSystem::setUserDefinedNumOfParticles(int numParticles)
    20691925{
    2070         if (numParticles < _particleMaxCount)
    2071                 _userDefinedParticleMaxCount = numParticles;
    2072         else
    2073                 _userDefinedParticleMaxCount = _particleMaxCount;
    2074         reset();
    2075 }
     1926    if (numParticles < _particleMaxCount)
     1927        _userDefinedParticleMaxCount = numParticles;
     1928    else
     1929        _userDefinedParticleMaxCount = _particleMaxCount;
     1930    reset();
     1931}
  • trunk/packages/vizservers/nanovis/ParticleSystemFactory.cpp

    r2802 r2805  
    6666    size_t cnt;
    6767
    68     while(! feof(fp)) {
     68    while (! feof(fp)) {
    6969        void *buff = XML_GetBuffer(parser, BUFSIZE);
    7070        if (! buff) {
Note: See TracChangeset for help on using the changeset viewer.