MStatus exampleRampAttrNode::initialize()
{
MStatus stat;
MString curveRamp("curveRamp");
MString cvr("cvr");
MString colorRamp("colorRamp");
MString clr("clr");
input1 = MRampAttribute::createCurveRamp(curveRamp, cvr);
input2 = MRampAttribute::createColorRamp(colorRamp, clr);
stat = addAttribute(input1);
if(!stat)
{
cout << "ERROR in adding curveRamp Attribute!\n";
}
stat = addAttribute(input2);
if(!stat)
{
cout << "ERROR in adding colorRamp Attribute!\n";
}
return stat;
}
void QgsColorRampButton::saveColorRamp()
{
QgsStyleSaveDialog saveDlg( this, QgsStyle::ColorrampEntity );
if ( !saveDlg.exec() || saveDlg.name().isEmpty() )
{
return;
}
// check if there is no symbol with same name
if ( mStyle->symbolNames().contains( saveDlg.name() ) )
{
int res = QMessageBox::warning( this, tr( "Save color ramp" ),
tr( "Color ramp with name '%1' already exists. Overwrite?" )
.arg( saveDlg.name() ),
QMessageBox::Yes | QMessageBox::No );
if ( res != QMessageBox::Yes )
{
return;
}
mStyle->removeColorRamp( saveDlg.name() );
}
QStringList colorRampTags = saveDlg.tags().split( ',' );
// add new symbol to style and re-populate the list
QgsColorRamp *ramp = colorRamp();
mStyle->addColorRamp( saveDlg.name(), ramp );
mStyle->saveColorRamp( saveDlg.name(), ramp, saveDlg.isFavorite(), colorRampTags );
setColorRampName( saveDlg.name() );
}
void ParticleSystem::_initialize(int numParticles){
assert(!m_bInitialized);
m_numParticles = numParticles;
//Allocate host storage
m_hPos = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hVel = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hReorderedPos = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hReorderedVel = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hHash = (uint *)malloc(m_numParticles * sizeof(uint));
m_hIndex = (uint *)malloc(m_numParticles * sizeof(uint));
m_hCellStart = (uint *)malloc(m_numGridCells * sizeof(uint));
m_hCellEnd = (uint *)malloc(m_numGridCells * sizeof(uint));
memset(m_hPos, 0, m_numParticles * 4 * sizeof(float));
memset(m_hVel, 0, m_numParticles * 4 * sizeof(float));
memset(m_hCellStart, 0, m_numGridCells * sizeof(uint));
memset(m_hCellEnd, 0, m_numGridCells * sizeof(uint));
//Allocate GPU data
shrLog("Allocating GPU Data buffers...\n\n");
allocateArray(&m_dPos, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dVel, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dReorderedPos, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dReorderedVel, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dHash, m_numParticles * sizeof(uint));
allocateArray(&m_dIndex, m_numParticles * sizeof(uint));
allocateArray(&m_dCellStart, m_numGridCells * sizeof(uint));
allocateArray(&m_dCellEnd, m_numGridCells * sizeof(uint));
if (!m_bQATest)
{
//Allocate VBO storage
m_posVbo = createVBO(m_numParticles * 4 * sizeof(float));
m_colorVBO = createVBO(m_numParticles * 4 * sizeof(float));
//Fill color buffer
glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO);
float *data = (float *)glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
float *ptr = data;
for(uint i = 0; i < m_numParticles; i++){
float t = (float)i / (float) m_numParticles;
#if 0
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
#else
colorRamp(t, ptr);
ptr += 3;
#endif
*ptr++ = 1.0f;
}
glUnmapBufferARB(GL_ARRAY_BUFFER);
}
setParameters(&m_params);
setParametersHost(&m_params);
m_bInitialized = true;
}
void
ParticleSystem::_initialize(int numParticles)
{
assert(!m_bInitialized);
m_numParticles = numParticles;
// allocate host storage
m_hPos = new float[m_numParticles*4];
m_hVel = new float[m_numParticles*4];
memset(m_hPos, 0, m_numParticles*4*sizeof(float));
memset(m_hVel, 0, m_numParticles*4*sizeof(float));
m_hCellStart = new uint[m_numGridCells];
memset(m_hCellStart, 0, m_numGridCells*sizeof(uint));
m_hCellEnd = new uint[m_numGridCells];
memset(m_hCellEnd, 0, m_numGridCells*sizeof(uint));
// allocate GPU data
unsigned int memSize = sizeof(float) * 4 * m_numParticles;
if (m_bUseOpenGL)
{
m_posVbo = createVBO(memSize);
registerGLBufferObject(m_posVbo, &m_cuda_posvbo_resource);
}
else
{
checkCudaErrors(cudaMalloc((void **)&m_cudaPosVBO, memSize)) ;
}
allocateArray((void **)&m_dVel, memSize);
allocateArray((void **)&m_dSortedPos, memSize);
allocateArray((void **)&m_dSortedVel, memSize);
allocateArray((void **)&m_dGridParticleHash, m_numParticles*sizeof(uint));
allocateArray((void **)&m_dGridParticleIndex, m_numParticles*sizeof(uint));
allocateArray((void **)&m_dCellStart, m_numGridCells*sizeof(uint));
allocateArray((void **)&m_dCellEnd, m_numGridCells*sizeof(uint));
if (m_bUseOpenGL)
{
m_colorVBO = createVBO(m_numParticles*4*sizeof(float));
registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource);
// fill color buffer
glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO);
float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
float *ptr = data;
for (uint i=0; i<m_numParticles; i++)
{
float t = i / (float) m_numParticles;
#if 0
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
#else
colorRamp(t, ptr);
ptr+=3;
#endif
*ptr++ = 1.0f;
}
glUnmapBufferARB(GL_ARRAY_BUFFER);
}
else
{
checkCudaErrors(cudaMalloc((void **)&m_cudaColorVBO, sizeof(float)*numParticles*4));
}
sdkCreateTimer(&m_timer);
setParameters(&m_params);
m_bInitialized = true;
}
void PoiseuilleFlowSystem::_initialize(int numParticles){
assert(!IsInitialized);
numParticles = numParticles;
hPos = new float[numParticles*4];
hVel = new float[numParticles*4];
hVelLeapFrog = new float[numParticles*4];
hMeasures = new float[numParticles*4];
hAcceleration = new float[numParticles*4];
memset(hPos, 0, numParticles*4*sizeof(float));
memset(hVel, 0, numParticles*4*sizeof(float));
memset(hVelLeapFrog, 0, numParticles*4*sizeof(float));
memset(hAcceleration, 0, numParticles*4*sizeof(float));
memset(hMeasures, 0, numParticles*4*sizeof(float));
for(uint i = 0; i < numParticles; i++) //todo: check density approximation
hMeasures[4*i+0] = params.restDensity;
unsigned int memSize = sizeof(float) * 4 * numParticles;
if (IsOpenGL) {
posVbo = createVBO(memSize);
registerGLBufferObject(posVbo, &cuda_posvbo_resource);
} else {
checkCudaErrors( cudaMalloc( (void **)&cudaPosVBO, memSize )) ;
}
allocateArray((void**)&dVel, memSize);
allocateArray((void**)&dVelLeapFrog, memSize);
allocateArray((void**)&dAcceleration, memSize);
allocateArray((void**)&dMeasures, memSize);
allocateArray((void**)&dSortedPos, memSize);
allocateArray((void**)&dSortedVel, memSize);
allocateArray((void**)&dHash, numParticles*sizeof(uint));
allocateArray((void**)&dIndex, numParticles*sizeof(uint));
allocateArray((void**)&dCellStart, numGridCells*sizeof(uint));
allocateArray((void**)&dCellEnd, numGridCells*sizeof(uint));
if (IsOpenGL) {
colorVBO = createVBO(numParticles*4*sizeof(float));
registerGLBufferObject(colorVBO, &cuda_colorvbo_resource);
// fill color buffer
glBindBufferARB(GL_ARRAY_BUFFER, colorVBO);
float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
float *ptr = data;
uint fluidParticles = params.fluidParticlesSize.x * params.fluidParticlesSize.y * params.fluidParticlesSize.z;
for(uint i=0; i < numParticles; i++) {
float t = 0.7f;
if(i < fluidParticles)
t = 0.5f;
if(((i % params.gridSize.x) == 0) && i < fluidParticles)
t = 0.2f;
colorRamp(t, ptr);
ptr+=3;
*ptr++ = 1.0f;
}
glUnmapBufferARB(GL_ARRAY_BUFFER);
} else {
checkCudaErrors( cudaMalloc( (void **)&cudaColorVBO, sizeof(float)*numParticles*4) );
}
setParameters(¶ms);
IsInitialized = true;
}
void QgsSingleBandPseudoColorRendererWidget::on_mClassifyButton_clicked()
{
int bandComboIndex = mBandComboBox->currentIndex();
if ( bandComboIndex == -1 || !mRasterLayer )
{
return;
}
//int bandNr = mBandComboBox->itemData( bandComboIndex ).toInt();
//QgsRasterBandStats myRasterBandStats = mRasterLayer->dataProvider()->bandStatistics( bandNr );
int numberOfEntries;
QgsColorRampShader::ColorRamp_TYPE interpolation = static_cast< QgsColorRampShader::ColorRamp_TYPE >( mColorInterpolationComboBox->itemData( mColorInterpolationComboBox->currentIndex() ).toInt() );
bool discrete = interpolation == QgsColorRampShader::DISCRETE;
QList<double> entryValues;
QVector<QColor> entryColors;
double min = lineEditValue( mMinLineEdit );
double max = lineEditValue( mMaxLineEdit );
QScopedPointer< QgsVectorColorRamp > colorRamp( mColorRampComboBox->currentColorRamp() );
if ( mClassificationModeComboBox->itemData( mClassificationModeComboBox->currentIndex() ).toInt() == Continuous )
{
if ( colorRamp.data() )
{
numberOfEntries = colorRamp->count();
entryValues.reserve( numberOfEntries );
if ( discrete )
{
double intervalDiff = max - min;
// remove last class when ColorRamp is gradient and discrete, as they are implemented with an extra stop
QgsVectorGradientColorRamp* colorGradientRamp = dynamic_cast<QgsVectorGradientColorRamp*>( colorRamp.data() );
if ( colorGradientRamp != NULL && colorGradientRamp->isDiscrete() )
{
numberOfEntries--;
}
else
{
// if color ramp is continuous scale values to get equally distributed classes.
// Doesn't work perfectly when stops are non equally distributed.
intervalDiff *= ( numberOfEntries - 1 ) / ( double )numberOfEntries;
}
// skip first value (always 0.0)
for ( int i = 1; i < numberOfEntries; ++i )
{
double value = colorRamp->value( i );
entryValues.push_back( min + value * intervalDiff );
}
entryValues.push_back( std::numeric_limits<double>::infinity() );
}
else
{
for ( int i = 0; i < numberOfEntries; ++i )
{
double value = colorRamp->value( i );
entryValues.push_back( min + value * ( max - min ) );
}
}
// for continuous mode take original color map colors
for ( int i = 0; i < numberOfEntries; ++i )
{
entryColors.push_back( colorRamp->color( colorRamp->value( i ) ) );
}
}
}
else // for other classification modes interpolate colors linearly
{
numberOfEntries = mNumberOfEntriesSpinBox->value();
if ( numberOfEntries < 2 )
return; // < 2 classes is not useful, shouldn't happen, but if it happens save it from crashing
if ( mClassificationModeComboBox->itemData( mClassificationModeComboBox->currentIndex() ).toInt() == Quantile )
{ // Quantile
int bandNr = mBandComboBox->itemData( bandComboIndex ).toInt();
//QgsRasterHistogram rasterHistogram = mRasterLayer->dataProvider()->histogram( bandNr );
double cut1 = std::numeric_limits<double>::quiet_NaN();
double cut2 = std::numeric_limits<double>::quiet_NaN();
QgsRectangle extent = mMinMaxWidget->extent();
int sampleSize = mMinMaxWidget->sampleSize();
// set min and max from histogram, used later to calculate number of decimals to display
mRasterLayer->dataProvider()->cumulativeCut( bandNr, 0.0, 1.0, min, max, extent, sampleSize );
entryValues.reserve( numberOfEntries );
if ( discrete )
{
double intervalDiff = 1.0 / ( numberOfEntries );
for ( int i = 1; i < numberOfEntries; ++i )
{
mRasterLayer->dataProvider()->cumulativeCut( bandNr, 0.0, i * intervalDiff, cut1, cut2, extent, sampleSize );
entryValues.push_back( cut2 );
}
entryValues.push_back( std::numeric_limits<double>::infinity() );
}
else
{
double intervalDiff = 1.0 / ( numberOfEntries - 1 );
for ( int i = 0; i < numberOfEntries; ++i )
{
mRasterLayer->dataProvider()->cumulativeCut( bandNr, 0.0, i * intervalDiff, cut1, cut2, extent, sampleSize );
entryValues.push_back( cut2 );
}
}
}
else // EqualInterval
{
entryValues.reserve( numberOfEntries );
if ( discrete )
{
// in discrete mode the lowest value is not an entry and the highest
// value is inf, there are ( numberOfEntries ) of which the first
// and last are not used.
double intervalDiff = ( max - min ) / ( numberOfEntries );
for ( int i = 1; i < numberOfEntries; ++i )
{
entryValues.push_back( min + i * intervalDiff );
}
entryValues.push_back( std::numeric_limits<double>::infinity() );
}
else
{
//because the highest value is also an entry, there are (numberOfEntries - 1) intervals
double intervalDiff = ( max - min ) / ( numberOfEntries - 1 );
for ( int i = 0; i < numberOfEntries; ++i )
{
entryValues.push_back( min + i * intervalDiff );
}
}
}
if ( !colorRamp.data() )
{
//hard code color range from blue -> red (previous default)
int colorDiff = 0;
if ( numberOfEntries != 0 )
{
colorDiff = ( int )( 255 / numberOfEntries );
}
entryColors.reserve( numberOfEntries );
for ( int i = 0; i < numberOfEntries; ++i )
{
QColor currentColor;
int idx = mInvertCheckBox->isChecked() ? numberOfEntries - i - 1 : i;
currentColor.setRgb( colorDiff*idx, 0, 255 - colorDiff * idx );
entryColors.push_back( currentColor );
}
}
else
{
entryColors.reserve( numberOfEntries );
for ( int i = 0; i < numberOfEntries; ++i )
{
int idx = mInvertCheckBox->isChecked() ? numberOfEntries - i - 1 : i;
entryColors.push_back( colorRamp->color((( double ) idx ) / ( numberOfEntries - 1 ) ) );
}
}
}
mColormapTreeWidget->clear();
QList<double>::const_iterator value_it = entryValues.begin();
QVector<QColor>::const_iterator color_it = entryColors.begin();
// calculate a reasonable number of decimals to display
double maxabs = log10( qMax( qAbs( max ), qAbs( min ) ) );
int nDecimals = qRound( qMax( 3.0 + maxabs - log10( max - min ), maxabs <= 15.0 ? maxabs + 0.49 : 0.0 ) );
for ( ; value_it != entryValues.end(); ++value_it, ++color_it )
{
QgsTreeWidgetItemObject* newItem = new QgsTreeWidgetItemObject( mColormapTreeWidget );
newItem->setText( ValueColumn, QString::number( *value_it, 'g', nDecimals ) );
newItem->setBackground( ColorColumn, QBrush( *color_it ) );
newItem->setText( LabelColumn, QString() );
newItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable );
connect( newItem, SIGNAL( itemEdited( QTreeWidgetItem*, int ) ),
this, SLOT( mColormapTreeWidget_itemEdited( QTreeWidgetItem*, int ) ) );
}
autoLabel();
emit widgetChanged();
}
void QgsColorRampButton::showColorRampDialog()
{
QgsPanelWidget *panel = QgsPanelWidget::findParentPanel( this );
bool panelMode = panel && panel->dockMode();
std::unique_ptr< QgsColorRamp > currentRamp( colorRamp() );
if ( !currentRamp )
return;
setColorRampName( QString() );
if ( currentRamp->type() == QLatin1String( "gradient" ) )
{
QgsGradientColorRamp *gradRamp = static_cast<QgsGradientColorRamp *>( currentRamp.get() );
QgsGradientColorRampDialog dlg( *gradRamp, this );
dlg.setWindowTitle( mColorRampDialogTitle );
if ( dlg.exec() )
{
setColorRamp( dlg.ramp().clone() );
}
}
else if ( currentRamp->type() == QLatin1String( "random" ) )
{
QgsLimitedRandomColorRamp *randRamp = static_cast<QgsLimitedRandomColorRamp *>( currentRamp.get() );
if ( panelMode )
{
QgsLimitedRandomColorRampWidget *widget = new QgsLimitedRandomColorRampWidget( *randRamp, this );
widget->setPanelTitle( tr( "Edit ramp" ) );
connect( widget, &QgsLimitedRandomColorRampWidget::changed, this, &QgsColorRampButton::rampWidgetUpdated );
panel->openPanel( widget );
}
else
{
QgsLimitedRandomColorRampDialog dlg( *randRamp, this );
if ( dlg.exec() )
{
setColorRamp( dlg.ramp().clone() );
}
}
}
else if ( currentRamp->type() == QLatin1String( "preset" ) )
{
QgsPresetSchemeColorRamp *presetRamp = static_cast<QgsPresetSchemeColorRamp *>( currentRamp.get() );
if ( panelMode )
{
QgsPresetColorRampWidget *widget = new QgsPresetColorRampWidget( *presetRamp, this );
widget->setPanelTitle( tr( "Edit ramp" ) );
connect( widget, &QgsPresetColorRampWidget::changed, this, &QgsColorRampButton::rampWidgetUpdated );
panel->openPanel( widget );
}
else
{
QgsPresetColorRampDialog dlg( *presetRamp, this );
if ( dlg.exec() )
{
setColorRamp( dlg.ramp().clone() );
}
}
}
else if ( currentRamp->type() == QLatin1String( "colorbrewer" ) )
{
QgsColorBrewerColorRamp *brewerRamp = static_cast<QgsColorBrewerColorRamp *>( currentRamp.get() );
if ( panelMode )
{
QgsColorBrewerColorRampWidget *widget = new QgsColorBrewerColorRampWidget( *brewerRamp, this );
widget->setPanelTitle( tr( "Edit ramp" ) );
connect( widget, &QgsColorBrewerColorRampWidget::changed, this, &QgsColorRampButton::rampWidgetUpdated );
panel->openPanel( widget );
}
else
{
QgsColorBrewerColorRampDialog dlg( *brewerRamp, this );
if ( dlg.exec() )
{
setColorRamp( dlg.ramp().clone() );
}
}
}
else if ( currentRamp->type() == QLatin1String( "cpt-city" ) )
{
QgsCptCityColorRamp *cptCityRamp = static_cast<QgsCptCityColorRamp *>( currentRamp.get() );
QgsCptCityColorRampDialog dlg( *cptCityRamp, this );
if ( dlg.exec() )
{
if ( dlg.saveAsGradientRamp() )
{
setColorRamp( dlg.ramp().cloneGradientRamp() );
}
else
{
setColorRamp( dlg.ramp().clone() );
}
}
}
}
void FluidSystem::_initialize(int numParticles)
{
assert(!m_bInitialized);
m_numParticles = numParticles;
// allocate host storage
m_hPos = new float[m_numParticles * 4];
m_hVel = new float[m_numParticles * 4];
m_hDen = new float[m_numParticles];//new just need 1 float to store density and pressure
m_hPre = new float[m_numParticles];//new
m_hColorf = new float[m_numParticles];//new
buoyancyPos = new float[m_numParticles*3];
memset(m_hPos, 0, m_numParticles * 4 * sizeof(float));
memset(m_hVel, 0, m_numParticles * 4 * sizeof(float));
memset(m_hDen, 0, m_numParticles * sizeof(float));//new just need 1 float to store density and pressure
memset(m_hPre, 0, m_numParticles * sizeof(float));//new
memset(m_hColorf, 0, m_numParticles * sizeof(float));//new
memset(buoyancyPos, 0, m_numParticles*3 * sizeof(float));
m_sortKeys.alloc(m_numParticles);
m_indices.alloc(m_numParticles, true, false, true); //create as index buffer ,to sort
m_hCellStart = new uint[m_numGridCells];
memset(m_hCellStart, 0, m_numGridCells*sizeof(uint));
m_hCellEnd = new uint[m_numGridCells];
memset(m_hCellEnd, 0, m_numGridCells*sizeof(uint));
// allocate GPU data
unsigned int memSize = sizeof(float) * 4 * m_numParticles;
unsigned int memSizetwo = sizeof(float) * m_numParticles;
unsigned int memSizethree = sizeof(float) *3* m_numParticles;
if (m_bUseOpenGL)
{
m_posVbo = createVBO(memSize);
m_velVBO = createVBO(memSize);
//obstaclePosVbo[0] = createVBO(memSize);
registerGLBufferObject(m_posVbo, &m_cuda_posvbo_resource);
registerGLBufferObject(m_velVBO, &m_cuda_velvbo_resource);
}
else
{
checkCudaErrors(cudaMalloc((void **)&m_cudaPosVBO, memSize)) ;
checkCudaErrors(cudaMalloc((void **)&m_cudaVelVBO, memSize));
}
allocateArray((void **)&m_dVel, memSize);
allocateArray((void **)&m_dDen, memSizetwo);
allocateArray((void **)&m_dPre, memSizetwo);
allocateArray((void **)&m_dColorf, memSizetwo);
allocateArray((void **)&buoyancyForce, memSizethree);
allocateArray((void **)&m_dSortedPos, memSize);
allocateArray((void **)&m_dSortedVel, memSize);
allocateArray((void **)&m_dSortedDen, memSizetwo);
allocateArray((void **)&m_dSortedPre, memSizetwo);
allocateArray((void **)&m_dSortedColorf, memSizetwo);
allocateArray((void **)&m_dGridParticleHash, m_numParticles*sizeof(uint));
allocateArray((void **)&m_dGridParticleIndex, m_numParticles*sizeof(uint));
allocateArray((void **)&m_dCellStart, m_numGridCells*sizeof(uint));
allocateArray((void **)&m_dCellEnd, m_numGridCells*sizeof(uint));
if (m_bUseOpenGL)
{
//m_colorVBO = createVBO(m_numParticles*4*sizeof(float));
m_colorVBO = createVBO(memSize);
registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource);
// fill color buffer
glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO);
float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
float *ptr = data;
for (uint i=0; i<m_numParticles; i++)
{
if (i < 450000){
float t = i / (float)m_numParticles;
colorRamp(0.1, 0.5, 0.7, ptr);
ptr += 3;
*ptr++ = 0.5f;
}
/*else if (250000 <= i&&i < 450000){
float t = i / (float)m_numParticles;
colorRamp(0, 1, 0, ptr);
ptr += 3;
*ptr++ = 0.5f;
}*/
else{
float t = i / (float)m_numParticles;
colorRamp(0, 0, 0, ptr);
ptr += 3;
*ptr++ = 1.0f;
}
}
glUnmapBufferARB(GL_ARRAY_BUFFER);
}
else
{
checkCudaErrors(cudaMalloc((void **)&m_cudaColorVBO, sizeof(float)*numParticles*4));
}
plusBuoyancyforce(buoyancyForce, m_numParticles);//initialize this value to 0;
sdkCreateTimer(&m_timer);
setParameters(&m_params);
m_bInitialized = true;
}
