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");
}
