void World::Step() { float delta = (float)mTimer.GetDelta(); delta = min(delta, 0.1f); timeBank += delta; deltaTime = 0.01f; deltaTimeScaled = deltaTime * DeltaTimeScalingFactor; deltaTimeScaledSquared = deltaTimeScaled * deltaTimeScaled; #if DEBUG || 1 timeBank = deltaTime + (deltaTime/2); #endif //while(timeBank > deltaTime) { //CalculateViscoElasticity(); UpdateGrid(); CalculateDensity(); CalculatePressure(); UpdateParticles(); DoCollision(); timeBank -= deltaTime; } }
State& State::operator=(const State& rhs) { if(this == &rhs) return *this; this->_mass = rhs._mass; this->_gravMod = rhs._gravMod; this->_position = rhs._position; this->_velocity = rhs._velocity; this->_acceleration = rhs._acceleration; this->_forces = rhs._forces; this->_impulses = rhs._impulses; this->_active = rhs._active; this->_mat = rhs._mat; IBoundingBox* bb = nullptr; if(rhs._bounding_rectangle && dynamic_cast<AABB*>(rhs._bounding_rectangle)) { bb = new AABB(*dynamic_cast<AABB*>(rhs._bounding_rectangle)); } if(rhs._bounding_rectangle && dynamic_cast<OBB*>(rhs._bounding_rectangle)) { bb = new OBB(*dynamic_cast<OBB*>(rhs._bounding_rectangle)); } this->_bounding_rectangle = bb; a2de::Shape* cs = nullptr; if(rhs._collision_shape) { cs = a2de::Shape::Clone(rhs._collision_shape); } this->_collision_shape = cs; this->_density = CalculateDensity(); this->_damper = rhs._damper; return *this; }
//----------------------------------------------------------------------------- // Name: CSimulationSpace::InterpolateDensitySpace( float fAlpha ) // Desc: calculate the current density space by interpolating the density spaces of the last phase and the next phase //----------------------------------------------------------------------------- void CSimulationSpace::InterpolateDensitySpace( float fAlpha) { if( fAlpha <= 0.0 ) // fAlpha is the interpolation factor { m_pCurrentDensitySpace = m_apDensitySpace[m_uLastPhaseIndex]; } else if( fAlpha >= 1.0 ) { // exchange the indexes of the last phase and the next phase; m_uLastPhaseIndex = m_uNextPhaseIndex; m_uNextPhaseIndex = !m_uLastPhaseIndex; // point current DensitySpace to the DensitySpace of last phase m_pCurrentDensitySpace = m_apDensitySpace[m_uLastPhaseIndex]; // Create the next DensitySpace of the next phase CelluarAutomate( m_uNextPhaseIndex ); CalculateDensity( m_uNextPhaseIndex ); } else { int index; for( int i = 0; i < m_iLength; i++ ) { for( int j = 0; j < m_iHeight; j++) { for( int k = 0; k < m_iWidth; k++ ) { if( ! IsCellInVolume(i,j,k,&index) ) continue; m_pMidDensitySpace[index] = (float)(( 1.0 - fAlpha ) * m_apDensitySpace[m_uLastPhaseIndex][index] + fAlpha * m_apDensitySpace[m_uNextPhaseIndex][index]); } } } m_pCurrentDensitySpace = m_pMidDensitySpace; } }
bool CSimulationSpace::Setup( UINT uLength, UINT uWidth, UINT uHigh ) { m_iLength = uLength; m_iWidth = uWidth; m_iHeight = uHigh; int size = uLength * uWidth * uHigh; m_uLastPhaseIndex = 0; m_uNextPhaseIndex = 1; m_iElapsedSteps = 0; if( NewByteSpace( size, &m_apHumSpace[0] ) && NewByteSpace( size, &m_apHumSpace[1] ) && NewByteSpace( size, &m_apCldSpace[0] ) && NewByteSpace( size, &m_apCldSpace[1] ) && NewByteSpace( size, &m_apActSpace[0] ) && NewByteSpace( size, &m_apActSpace[1] ) && NewByteSpace( size, &m_pActFactorSpace ) && NewFloatSpace( size, &m_apDensitySpace[0] ) && NewFloatSpace( size, &m_apDensitySpace[1] ) && NewByteSpace( size, &m_pShapeSpace ) && NewFloatSpace( size, &m_pHumProbSpace ) && NewFloatSpace( size, &m_pExtProbSpace ) && NewFloatSpace( size, &m_pActProbSpace ) && NewFloatSpace( size, &m_pMidDensitySpace ) ) { m_uTotalNumCells = size; InitProbSpace(); ShapeVolume(); CelluarAutomate( m_uNextPhaseIndex ); CalculateDensity( m_uNextPhaseIndex ); return true; } else return false; }
void OpenSMOKE_MatrixSparsityPattern::FindDependence() { const int max_length_int_vector = static_cast<int> (std::pow(2., 32.) - 1); if (is_dependence_available_ == true) return; is_dependence_available_ = true; ElementSparsityPattern *elem; number_elements_ = 0; max_elements_in_rows_ = 0; min_elements_in_rows_ = columns_; max_elements_in_cols_ = 0; min_elements_in_cols_ = rows_; number_equations_per_variable_ = new int[columns_ + 1]; memset(number_equations_per_variable_, 0, (columns_ + 1)*sizeof(int)); int maxRow, minRow; OpenSMOKE::OpenSMOKEVectorInt elementsInColumn(columns_); number_zeros_on_diagonal_ = 0; for (int row = 1; row <= rows_; row++) { maxRow = 0; minRow = 0; elem = element_row_[row]; while (elem != 0) { elementsInColumn(elem->column)++; if (elem->column == row) number_zeros_on_diagonal_++; maxRow++; minRow++; number_elements_++; number_equations_per_variable_[elem->column]++; if (number_elements_ == max_length_int_vector) OpenSMOKE::FatalErrorMessage("MatrixSparsityPattern::FindDependence(): Too many element dependencies"); elem = elem->next; } if (maxRow > max_elements_in_rows_) { max_elements_in_rows_ = maxRow; index_max_row_ = row; } if (minRow < min_elements_in_rows_) { min_elements_in_rows_ = minRow; index_min_row_ = row; } } max_elements_in_cols_ = elementsInColumn.Max(&index_max_col_); min_elements_in_cols_ = elementsInColumn.Min(&index_min_col_); number_zeros_on_diagonal_ = Min(rows_, columns_) - number_zeros_on_diagonal_; dependencies_ = new int *[columns_ + 1]; dependencies_[0] = new int[number_elements_ + 1]; dependencies_[1] = dependencies_[0]; int *ptrInt = dependencies_[0] + 1; int *ivar = new int[columns_ + 1]; memset(ivar, 0, (columns_ + 1)*sizeof(int)); for (int var = 1; var < columns_; var++) dependencies_[var + 1] = dependencies_[var] + number_equations_per_variable_[var]; for (int row = 1; row <= rows_; row++) { elem = element_row_[row]; while (elem != 0) { ivar[elem->column]++; dependencies_[elem->column][ivar[elem->column]] = row; elem = elem->next; } } delete ivar; ptrInt = dependencies_[0] + 1; char *tempFunz = new char[rows_ + 1]; char *tempVar = new char[columns_ + 1]; memset(tempVar, 0, (columns_ + 1)*sizeof(char)); ptr_derivatives_ = new int[columns_ + 1]; int *tempDer = new int[columns_ + 1]; int k; int ider = 1; int jder = 1; int kder; number_groups_ = 0; int var; while (1) { memset(tempFunz, 0, (rows_ + 1)*sizeof(char)); for (var = 1; var <= columns_; var++) if (tempVar[var] == 0) break; if (var > columns_) break; tempVar[var] = 1; ptr_derivatives_[ider++] = var; number_groups_++; kder = 1; for (k = 1; k <= number_equations_per_variable_[var]; k++) tempFunz[dependencies_[var][k]] = 1; while (1) { for (var += 1; var <= columns_; var++) if (tempVar[var] == 0)break; if (var > columns_) { tempDer[jder++] = kder; break; } char no = 0; for (k = 1; k <= number_equations_per_variable_[var]; k++) { if (tempFunz[dependencies_[var][k]] == 1) { no = 1; break; } } if (no == 0) { for (k = 1; k <= number_equations_per_variable_[var]; k++) tempFunz[dependencies_[var][k]] = 1; tempVar[var] = 1; ptr_derivatives_[ider++] = var; kder++; } } } variable_in_group_ = new int *[number_groups_ + 1]; number_variables_in_group_ = new int[number_groups_ + 1]; var = 0; for (k = 1; k <= number_groups_; k++) { number_variables_in_group_[k] = tempDer[k]; variable_in_group_[k] = &ptr_derivatives_[var]; var += tempDer[k]; } max_number_of_elements_ = rows_*columns_; delete tempFunz; delete tempVar; delete tempDer; // Additional analyses AnalyzeBand(); CalculateDensity(); }
void State::SetMass(double mass) { this->_mass = mass; this->_density = CalculateDensity(); }
State::State(const State& other) : _mass(other._mass), _gravMod(other._gravMod), _position(other._position), _velocity(other._velocity), _acceleration(other._acceleration), _forces(other._forces), _impulses(other._impulses), _active(other._active), _mat(other._mat), _bounding_rectangle(nullptr), _collision_shape(nullptr), _density(), _damper(DEFAULT_DAMPER_VALUE) { SetBoundingRectangle(other._bounding_rectangle); SetCollisionShape(other._collision_shape); _density = CalculateDensity(); }
State::State(double mass, const Vector2D& gravMod, const Vector2D& position, const Vector2D& velocity, double restitution, double static_friction, double kinetic_friction) : _mass(mass), _gravMod(gravMod), _position(position), _velocity(velocity), _acceleration(0.0, 0.0), _forces(), _impulses(), _active(true), _mat(restitution, static_friction, kinetic_friction), _bounding_rectangle(nullptr), _collision_shape(nullptr), _density(), _damper(DEFAULT_DAMPER_VALUE) { SetBoundingRectangle(_bounding_rectangle); SetCollisionShape(_collision_shape); _density = CalculateDensity(); }
void State::SetBoundingRectangle(IBoundingBox* rectangle) { delete _bounding_rectangle; _bounding_rectangle = rectangle; _density = CalculateDensity(); }