HashReturn Update(hashState_sd *state, const BitSequence *data, DataLength databitlen) { unsigned current; unsigned int bs = state->blocksize; static int align = -1; if (align == -1) align = RequiredAlignment(); #ifdef HAS_64 current = state->count & (bs - 1); #else current = state->count_low & (bs - 1); #endif if (current & 7) { /* * The number of hashed bits is not a multiple of 8. * Very painfull to implement and not required by the NIST API. */ return FAIL; } while (databitlen > 0) { if (IS_ALIGNED(data,align) && current == 0 && databitlen >= bs) { /* * We can hash the data directly from the input buffer. */ SIMD_Compress(state, data, 0); databitlen -= bs; data += bs/8; IncreaseCounter(state, bs); } else { /* * Copy a chunk of data to the buffer */ unsigned int len = bs - current; if (databitlen < len) { memcpy(state->buffer+current/8, data, (databitlen+7)/8); IncreaseCounter(state, databitlen); return SUCCESS; } else { memcpy(state->buffer+current/8, data, len/8); IncreaseCounter(state,len); databitlen -= len; data += len/8; current = 0; SIMD_Compress(state, state->buffer, 0); } } } return SUCCESS; }
void UnitStateMgr::PushAction(UnitActionId actionId, UnitActionPtr state, UnitActionPriority priority, eActionType restoreable) { ActionInfo* oldInfo = CurrentState(); UnitActionPriority _priority = oldInfo ? oldInfo->priority : UNIT_ACTION_PRIORITY_IDLE; // Only interrupt action, if not drop his below and action lower by priority if (oldInfo && oldInfo->HasFlag(ACTION_STATE_ACTIVE) && oldInfo->Id != actionId && _priority < priority) oldInfo->Interrupt(this); if (_priority > UNIT_ACTION_PRIORITY_IDLE) { // Some speedup - testing - not need drop Idle/None actions DropAction(actionId, priority); DropAction(priority); } bool needInsert = true; if (restoreable != ACTION_TYPE_NONRESTOREABLE) { // Don't replace (only interrupt and reset!) restoreable actions UnitActionStorage::iterator itr = m_actions.find(priority); if (itr != m_actions.end()) { if (itr->second.Id == actionId) { itr->second.Reset(this); needInsert = false; } } } if (needInsert) m_actions.insert(UnitActionStorage::value_type(priority,ActionInfo(actionId, state, priority, restoreable))); IncreaseCounter(actionId); /* ActionInfo* newInfo = CurrentState(); if (newInfo && newInfo != oldInfo) { if (!newInfo->HasFlag(ACTION_STATE_INITIALIZED)) newInfo->Initialize(this); } */ }
void ReadManager::UpdateCoverage(ScreenBase const & screen, bool is3dBuildings, TTilesCollection const & tiles, ref_ptr<dp::TextureManager> texMng) { if (screen == m_currentViewport && !m_forceUpdate) return; m_forceUpdate = false; m_modeChanged |= m_need3dBuildings != is3dBuildings; m_need3dBuildings = is3dBuildings; if (m_modeChanged || MustDropAllTiles(screen)) { m_modeChanged = false; IncreaseCounter(static_cast<int>(tiles.size())); m_generationCounter++; for_each(m_tileInfos.begin(), m_tileInfos.end(), bind(&ReadManager::CancelTileInfo, this, _1)); m_tileInfos.clear(); for_each(tiles.begin(), tiles.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1, texMng)); } else { // Find rects that go out from viewport buffer_vector<shared_ptr<TileInfo>, 8> outdatedTiles; #ifdef _MSC_VER vs_bug:: #endif set_difference(m_tileInfos.begin(), m_tileInfos.end(), tiles.begin(), tiles.end(), back_inserter(outdatedTiles), LessCoverageCell()); // Find rects that go in into viewport. buffer_vector<TileKey, 8> inputRects; #ifdef _MSC_VER vs_bug:: #endif set_difference(tiles.begin(), tiles.end(), m_tileInfos.begin(), m_tileInfos.end(), back_inserter(inputRects), LessCoverageCell()); // Find tiles which must be re-read. buffer_vector<shared_ptr<TileInfo>, 8> rereadTiles; for (shared_ptr<TileInfo> const & tile : m_tileInfos) { for (shared_ptr<TileInfo> & outTile : outdatedTiles) { if (IsNeighbours(tile->GetTileKey(), outTile->GetTileKey())) { rereadTiles.push_back(tile); break; } } } IncreaseCounter(static_cast<int>(inputRects.size() + rereadTiles.size())); for_each(outdatedTiles.begin(), outdatedTiles.end(), bind(&ReadManager::ClearTileInfo, this, _1)); for_each(rereadTiles.begin(), rereadTiles.end(), bind(&ReadManager::PushTaskFront, this, _1)); for_each(inputRects.begin(), inputRects.end(), bind(&ReadManager::PushTaskBackForTileKey, this, _1, texMng)); } m_currentViewport = screen; }
//If the cell is alive, then it stays alive if it has either 2 or 3 live neighbors //If the cell is dead, then it springs to life only in the case that it has 3 live neighbors void Generation::Calculate(void) { AppLog("Calculation started"); int siblingNum = 0; for (int i=1; i<columns-1; i++) { for (int j=1; j<rows-1; j++) { siblingNum = 0; // INSIDE FIELD (>1 CELL FROM EDGE) siblingNum += (int)currentGeneration[(i-1)][(j-1)]; siblingNum += (int)currentGeneration[(i-1)][j]; siblingNum += (int)currentGeneration[(i-1)][(j+1)]; siblingNum += (int)currentGeneration[i][(j-1)]; siblingNum += (int)currentGeneration[i][(j+1)]; siblingNum += (int)currentGeneration[(i+1)][(j-1)]; siblingNum += (int)currentGeneration[(i+1)][j]; siblingNum += (int)currentGeneration[(i+1)][(j+1)]; nextGeneration[i][j] = MakeAlive(currentGeneration[i][j], siblingNum); } } // START SETTING EDGE CELLS if (surface == SURFACE_THOR) { // _C|D____C|D_ // B|A B|A // | | // _C|D____C|D_ // B|A B|A for (int i = 0; i < columns-1; i++) { top[i] = currentGeneration[i][rows-1]; bottom[i] = currentGeneration[i][0]; } for (int j = 0; j < rows-1; j++) { left[j] = currentGeneration[columns-1][j]; right[j] = currentGeneration[1][j]; } topLeft = currentGeneration[columns-1][rows-1]; topRight = currentGeneration[0][rows-1]; bottomRight = currentGeneration[0][0]; bottomLeft = currentGeneration[columns-1][0]; } else if (surface == SURFACE_KLEIN) { // _D|C____D|C_ // B|A B|A // | | // _C|D____C|D_ // A|B A|B for (int i = 0; i < columns-1; i++) { top[i] = currentGeneration[columns-1-i][rows-1]; bottom[i] = currentGeneration[columns-1-i][0]; } for (int j = 0; j < rows-1; j++) { left[j] = currentGeneration[columns-1][j]; right[j] = currentGeneration[1][j]; } topLeft = currentGeneration[0][rows-1]; topRight = currentGeneration[columns-1][rows-1]; bottomRight = currentGeneration[columns-1][0]; bottomLeft = currentGeneration[0][0]; } else if (surface == SURFACE_PROJECTIVE) { // _B|C____D|A_ // D|A B|C // | | // _A|D____C|B_ // C|B A|D for (int i = 0; i < columns-1; i++) { top[i] = currentGeneration[columns-1-i][rows-1]; bottom[i] = currentGeneration[columns-1-i][0]; } for (int j = 0; j < rows-1; j++) { left[j] = currentGeneration[columns-1][rows-j-1]; right[j] = currentGeneration[1][rows-j-1]; } topLeft = currentGeneration[columns-1][0]; topRight = currentGeneration[0][0]; bottomRight = currentGeneration[0][rows-1]; bottomLeft = currentGeneration[columns-1][rows-1]; } // END SETTING EDGE CELLS for (int i=1; i<columns-1; i++) { // FIRST ROW siblingNum = 0; siblingNum += (int) currentGeneration[i-1][1]; siblingNum += (int) currentGeneration[i-1][0]; siblingNum += (int) top[i-1]; siblingNum += (int) currentGeneration[i][1]; siblingNum += (int) top[i]; siblingNum += (int) currentGeneration[i+1][1]; siblingNum += (int) currentGeneration[i+1][0]; siblingNum += (int) top[i+1]; nextGeneration[i][0] = MakeAlive(currentGeneration[i][0], siblingNum); // LAST ROW siblingNum = 0; siblingNum += (int) currentGeneration[i-1][rows-2]; siblingNum += (int) currentGeneration[i-1][rows-1]; siblingNum += (int) bottom[i-1]; siblingNum += (int) currentGeneration[i][rows-2]; siblingNum += (int) bottom[i]; siblingNum += (int) currentGeneration[i+1][rows-2]; siblingNum += (int) currentGeneration[i+1][rows-1]; siblingNum += (int) bottom[i+1]; nextGeneration[i][rows-1] = MakeAlive(currentGeneration[i][rows-1], siblingNum); } for (int i=1; i< rows-1; i++) { // FIRST COLUMN siblingNum = 0; siblingNum += (int) left[i-1]; siblingNum += (int) left[i]; siblingNum += (int) left[i+1]; siblingNum += (int) currentGeneration[0][i-1]; siblingNum += (int) currentGeneration[0][i+1]; siblingNum += (int) currentGeneration[1][i-1]; siblingNum += (int) currentGeneration[1][i]; siblingNum += (int) currentGeneration[1][i+1]; nextGeneration[0][i] = MakeAlive(currentGeneration[0][i], siblingNum); // LAST COLUMN siblingNum = 0; siblingNum += (int) currentGeneration[columns-2][i-1]; siblingNum += (int) currentGeneration[columns-2][i]; siblingNum += (int) currentGeneration[columns-2][i+1]; siblingNum += (int) currentGeneration[columns-1][i-1]; siblingNum += (int) currentGeneration[columns-1][i+1]; siblingNum += (int) right[i-1]; siblingNum += (int) right[i]; siblingNum += (int) right[i+1]; nextGeneration[columns-1][i] = MakeAlive(currentGeneration[columns-1][i], siblingNum); } // TOP LEFT siblingNum = 0; siblingNum += (int) topLeft; siblingNum += (int) top[0]; siblingNum += (int) top[1]; siblingNum += (int) currentGeneration[0][1]; siblingNum += (int) currentGeneration[1][1]; siblingNum += (int) currentGeneration[1][0]; siblingNum += (int) left[1]; siblingNum += (int) left[0]; nextGeneration[0][0] = MakeAlive(currentGeneration[0][0], siblingNum); // TOP RIGHT siblingNum = 0; siblingNum += (int) top[columns-2]; siblingNum += (int) top[columns-1]; siblingNum += (int) topRight; siblingNum += (int) right[0]; siblingNum += (int) right[1]; siblingNum += (int) currentGeneration[columns-1][1]; siblingNum += (int) currentGeneration[columns-2][1]; siblingNum += (int) currentGeneration[columns-2][0]; nextGeneration[columns-1][0] = MakeAlive(currentGeneration[columns-1][0], siblingNum); // BOTTOM RIGHT siblingNum = 0; siblingNum += (int) currentGeneration[columns-2][rows-2]; siblingNum += (int) currentGeneration[columns-1][rows-2]; siblingNum += (int) right[rows-2]; siblingNum += (int) right[rows-1]; siblingNum += (int) bottomRight; siblingNum += (int) bottom[columns-1]; siblingNum += (int) bottom[columns-2]; siblingNum += (int) currentGeneration[columns-2][rows-1]; nextGeneration[columns-1][rows-1] = MakeAlive(currentGeneration[columns-1][rows-1], siblingNum); // TOP LEFT siblingNum = 0; siblingNum += (int) left[rows-2]; siblingNum += (int) currentGeneration[0][rows-2]; siblingNum += (int) currentGeneration[1][rows-2]; siblingNum += (int) currentGeneration[1][rows-1]; siblingNum += (int) bottom[1]; siblingNum += (int) bottom[0]; siblingNum += (int) bottomLeft; siblingNum += (int) left[rows-1]; nextGeneration[0][rows-1] = MakeAlive(currentGeneration[0][rows-1], siblingNum); for (int i=0; i<columns; i++) { for (int j=0; j<rows; j++) { currentGeneration[i][j] = nextGeneration[i][j]; } } IncreaseCounter(); AppLog("Calculation ended"); }