static INT get_offset (INT n)
{
INT i,subtreesize[50],sum,offset;
/* get number of objects downtree */
sum = n;
for (i=0; i<degree; i++) {
GetConcentrate(i,subtreesize+i,sizeof(INT));
sum += subtreesize[i];
}
/* get offset */
if (me==master)
{
offset = 0;
}
else
{
Concentrate(&sum,sizeof(INT));
GetSpread(&offset,sizeof(INT));
}
/* send offsets for downtree nodes */
sum = offset+n;
for (i=0; i<degree; i++) {
Spread(i,&sum,sizeof(INT));
sum += subtreesize[i];
}
return(offset);
}
void mpc_psy_model_init_tables(PsyModel *m)
{
m->Max_Band = (int) ( m->BandWidth * 64. / m->SampleFreq );
if ( m->Max_Band < 1 ) m->Max_Band = 1;
if ( m->Max_Band > 31 ) m->Max_Band = 31;
Tonalitaetskoeffizienten (m);
Ruhehoerschwelle ( m, m->EarModelFlag, m->Ltq_offset, m->Ltq_max );
Loudness_Tabelle (m);
Spread (m);
}
void GoInfluence::ComputeInfluence(const GoBoard& bd,
const SgBWSet& stopPts,
SgBWArray<SgPointArray<int> >* influence)
{
const int MAX_INFLUENCE = 64;
for (SgBWIterator it; it; ++it)
{
SgBlackWhite color = *it;
((*influence)[color]).Fill(0);
for (GoBoard::Iterator it(bd); it; ++it)
{
SgPoint p(*it);
if (bd.IsColor(p, color))
Spread(bd, p, stopPts[color], MAX_INFLUENCE,
(*influence)[color]);
}
}
}
int NotifyTwoWave (NOTIFY_INFO *allInfos, int lastInfo, int exception)
{
NOTIFY_INFO *newInfos;
int l, i, j, n, unknownInfos, myInfos;
int local_exception = exception;
#if DebugNotify<=4
printf("%4d: NotifyTwoWave, lastInfo=%d\n", me, lastInfo);
fflush(stdout);
#endif
/* BOTTOM->TOP WAVE */
/* get local Info lists from downtree */
for(l=degree-1; l>=0; l--)
{
GetConcentrate(l, &n, sizeof(int));
if (n<0)
{
/* exception from downtree, propagate */
if (-n > local_exception)
local_exception = -n;
}
if (lastInfo+n >= maxInfos) {
DDD_PrintError('E', 6321, "msg-info array overflow in NotifyTwoWave");
local_exception = EXCEPTION_NOTIFY;
/* receive data, but put it onto dummy position */
GetConcentrate(l, allInfos, n*sizeof(NOTIFY_INFO));
}
else
{
if (n>0)
GetConcentrate(l, &(allInfos[lastInfo]), n*sizeof(NOTIFY_INFO));
}
/* construct routing table */
for(i=0; i<n; i++)
theRouting[allInfos[lastInfo+i].from] = l;
if (n>0)
lastInfo += n;
}
if (! local_exception)
{
/* determine target direction in tree */
/* TODO: eventually extra solution for root node!
(it knows all flags are MYSELF or KNOWN!) */
qsort(allInfos, lastInfo, sizeof(NOTIFY_INFO), sort_XferInfos);
i = j = 0;
unknownInfos = lastInfo;
myInfos = 0;
while (i<lastInfo && allInfos[j].to==PROC_INVALID_TEMP)
{
if (allInfos[j].from==allInfos[i].to)
{
allInfos[i].flag = (allInfos[i].to==me) ? MYSELF : KNOWN;
unknownInfos--;
if (allInfos[i].to==me)
myInfos++;
i++;
} else {
if (allInfos[j].from<allInfos[i].to)
j++;
else
i++;
}
}
qsort(allInfos, lastInfo, sizeof(NOTIFY_INFO), sort_XferFlags);
/* send local Info list uptree, but only unknown Infos */
newInfos = &allInfos[lastInfo-unknownInfos];
Concentrate(&unknownInfos, sizeof(int));
Concentrate(newInfos, unknownInfos*sizeof(NOTIFY_INFO));
lastInfo -= unknownInfos;
#if DebugNotify<=1
for(i=0; i<unknownInfos; i++)
{
printf("%4d: NotifyTwoWave, "
"send uptree unknown %d/%d (%d|%d;%d)\n",
me, i, unknownInfos,
newInfos[i].to, newInfos[i].from, newInfos[i].size);
}
#endif
}
else
{
/* we have an exception somewhere in the processor tree */
/* propagate it */
int neg_exception = -local_exception;
Concentrate(&neg_exception, sizeof(int));
/* don't need to send data now */
}
#if DebugNotify<=3
printf("%4d: NotifyTwoWave, wave 1 ready\n", me);
fflush(stdout);
#endif
/* TOP->BOTTOM WAVE */
/* get Infos local to my subtree from uptree */
unknownInfos = 0;
GetSpread(&unknownInfos, sizeof(int));
if (unknownInfos<0)
{
/* exception from downtree, propagate */
if (-unknownInfos > local_exception)
local_exception = -unknownInfos;
}
if (unknownInfos>0)
{
GetSpread(newInfos, unknownInfos*sizeof(NOTIFY_INFO));
lastInfo += unknownInfos;
}
if (! local_exception)
{
/* sort Infos according to routing */
qsort(allInfos, lastInfo, sizeof(NOTIFY_INFO), sort_XferRouting);
#if DebugNotify<=1
for(i=0; i<lastInfo; i++)
{
printf("%4d: NotifyTwoWave, "
"sorted for routing %d/%d (%d|%d;%d)\n",
me, i, lastInfo,
allInfos[i].to, allInfos[i].from, allInfos[i].size);
}
#endif
/* send relevant Infos downtree */
i = 0;
unknownInfos = lastInfo;
while ((i<unknownInfos)&&(allInfos[i].to==me)) i++;
lastInfo = i;
for(l=0; l<degree; l++)
{
j = i;
while ((i<unknownInfos)&&(theRouting[allInfos[i].to]==l)) i++;
j = i-j;
Spread(l, &j, sizeof(int));
if (j>0)
Spread(l, &allInfos[i-j], j*sizeof(NOTIFY_INFO));
}
/* reuse theDescs-array for registering messages to be received */
for(i=0; i<lastInfo; i++)
{
theDescs[i].proc = allInfos[i].from;
theDescs[i].size = allInfos[i].size;
}
#if DebugNotify<=3
printf("%4d: NotifyTwoWave, "
"wave 2 ready, nRecv=%d\n", me, lastInfo);
fflush(stdout);
#endif
}
else
{
/* we received an exception from uptree, propagate it */
for(l=0; l<degree; l++)
{
int neg_exception = -local_exception;
Spread(l, &neg_exception, sizeof(int));
/* dont send any data */
}
#if DebugNotify<=3
printf("%4d: NotifyTwoWave, "
"wave 2 ready, Exception=%d\n", me, local_exception);
fflush(stdout);
#endif
return(-local_exception);
}
return(lastInfo);
}
BOOL TableClass::Layout (struct LayoutMessage &lmsg)
{
if(Flags & FLG_AllElementsPresent)
{
FindImage(lmsg);
if(!(Flags & FLG_AllocatedColours))
AllocateColours(lmsg.Share->Scr->ViewPort.ColorMap);
if(lmsg.Y != lmsg.MinY || !lmsg.IsAtNewline())
lmsg.AddYSpace(4);
lmsg.EnsureNewline();
Top = lmsg.Y;
Left = lmsg.X;
lmsg.TopChange = min(Top, lmsg.TopChange);
if(!(Flags & FLG_KnowsMinMax))
{
struct MinMaxMessage mmsg(lmsg.Share->Fonts, &lmsg);
mmsg.Reset();
MinMax(mmsg);
}
ULONG scr_width = lmsg.ScrWidth() - (Columns+1)*Spacing - 2*BorderSize;
if(GivenWidth)
{
if(GivenWidth->Type == Size_Percent)
Width = max(Min, ((lmsg.ScrWidth() * GivenWidth->Size) / 100) - (Columns+1)*Spacing - 2*BorderSize);
else
Width = max(GivenWidth->Size-(Columns+1)*Spacing-2*BorderSize, Min);
}
else
Width = (Min <= scr_width) ? min(scr_width, Max) : Min;
/* Set all cells to their min or max width */
LONG scale = Width, table_delta = 0, relative = 0;
for(ULONG i = 0; i < Columns; i++)
{
if(!Widths[i].Percent)
{
LONG cellwidth = Width >= Max ? Widths[i].Max : Widths[i].Min;
table_delta += Widths[i].Max - Widths[i].Min;
scale -= cellwidth;
relative += Widths[i].Relative;
Widths[i].Width = cellwidth;
}
}
/* Set all cells with a width given in percent */
for(ULONG i = 0; i < Columns; i++)
{
if(Widths[i].Percent)
{
ULONG cellwidth = max(Widths[i].Min, min((ULONG)scale, (Width * Widths[i].Percent) / 100));
Widths[i].Width = cellwidth;
scale -= cellwidth;
}
}
if(scale > 0)
{
if(relative)
{
Spread(scale, relative, RelativeScale);
}
else if(table_delta)
{
Spread(scale, table_delta, NormalScale);
}
else
{
LONG width = Max;
for(UWORD i = 0; i < Columns; i++)
{
if(Widths[i].Fixed)
width -= Widths[i].Max;
}
if(width)
Spread(scale, width, LeftOverScale);
else Width -= scale;
}
}
else
{
Width -= scale;
}
struct CellWidth *oldwidths = lmsg.Widths;
ULONG oldspace = lmsg.Spacing, oldpad = lmsg.Padding;
struct TextFont *oldfont = lmsg.Font;
ULONG oldcols = lmsg.Columns, oldimageleftindent = lmsg.ImageLeftIndent, oldimagerightindent = lmsg.ImageRightIndent;
lmsg.ImageLeftIndent = lmsg.ImageRightIndent = 0;
struct FloadingImage *fleft = lmsg.FLeft, *fright = lmsg.FRight;
lmsg.FLeft = lmsg.FRight = NULL;
lmsg.Widths = Widths;
lmsg.Spacing = Spacing;
lmsg.Padding = Padding + (BorderSize ? 1 : 0);
lmsg.Columns = Columns;
ULONG oldminx = lmsg.MinX;
lmsg.MinX = lmsg.X += BorderSize;
lmsg.AddYSpace(Spacing+BorderSize);
Flags &= ~FLG_Virgin;
ULONG *oldopencounts = lmsg.RowOpenCounts;
lmsg.RowOpenCounts = (ULONG *)memset(RowOpenCounts, 0, Columns * sizeof(ULONG));
ULONG *oldheights = lmsg.Heights;
ULONG pass = lmsg.Pass;
lmsg.Pass = 0;
lmsg.Heights = (ULONG *)memset(Heights, 0, Rows*sizeof(ULONG));
ULONG realrows = 0;
struct ChildsList *first = FirstChild;
while(first)
{
((class TRClass *)first->Obj)->TRLayout(lmsg);
first = first->Next;
realrows++;
}
/* Should some cell set a rowspan that ends outside the table, then we enlarge all height entries */
while(realrows < Rows)
{
Heights[realrows] = max(Heights[realrows], Heights[realrows-1]);
realrows++;
}
Bottom = Rows ? Heights[Rows-1] : lmsg.Y;
lmsg.Y = Bottom + Spacing;
lmsg.Pass = 1;
lmsg.Heights = Heights;
first = FirstChild;
while(first)
{
((class TRClass *)first->Obj)->TRLayout(lmsg);
first = first->Next;
}
lmsg.Pass = pass;
lmsg.Heights = oldheights;
lmsg.RowOpenCounts = oldopencounts;
lmsg.MinX = oldminx;
lmsg.AddYSpace(BorderSize);
lmsg.Widths = oldwidths;
lmsg.Columns = oldcols;
lmsg.Spacing = oldspace;
lmsg.Padding = oldpad;
lmsg.FLeft = fleft;
lmsg.FRight = fright;
lmsg.ImageLeftIndent = oldimageleftindent;
lmsg.ImageRightIndent = oldimagerightindent;
lmsg.X += oldimageleftindent;
lmsg.Font = oldfont;
lmsg.Width = max((ULONG)lmsg.Width, lmsg.MinX+Width+((Columns+1)*Spacing)+2*BorderSize+lmsg.MarginWidth+lmsg.ImageRightIndent);
Bottom = lmsg.Y-1;
lmsg.AddYSpace(4);
LONG width = Width+((Columns+1)*Spacing)+2*BorderSize;
LONG delta = lmsg.ScrWidth() - width;
UBYTE oldalign = lmsg.Align;
if(delta > 0)
{
LONG offset = 0;
if(Alignment == Align_Left || Alignment == Align_Right)
{
LONG width = Width + (Columns+1)*Spacing + 2*BorderSize;
struct FloadingImage *img = new (std::nothrow) struct FloadingImage(Top, Left, width, (Bottom-Top)+1, this, lmsg.Parent);
if (img)
{
LONG left = lmsg.AddImage(img, Alignment == Align_Right);
offset = left - Left;
}
lmsg.Y = Top;
lmsg.Baseline = lmsg.Bottom = 0;
}
else if(lmsg.Align == Align_Center || Alignment == Align_Center)
{
offset = delta/2;
}
else if(lmsg.Align == Align_Right)
{
offset = delta;
}
if(offset)
AdjustPosition(offset, 0);
}
lmsg.Align = oldalign;
if(Alignment != Align_Left && Alignment != Align_Right)
lmsg.CheckFloatingObjects();
Flags |= FLG_Layouted;
}
else
{
lmsg.TopChange = min(lmsg.TopChange, MAX_HEIGHT);
}
return TRUE;
}
void cFloodyFluidSimulator::SimulateBlock(cChunk * a_Chunk, int a_RelX, int a_RelY, int a_RelZ)
{
FLOG("Simulating block {%d, %d, %d}: block %d, meta %d",
a_Chunk->GetPosX() * cChunkDef::Width + a_RelX, a_RelY, a_Chunk->GetPosZ() * cChunkDef::Width + a_RelZ,
a_Chunk->GetBlock(a_RelX, a_RelY, a_RelZ),
a_Chunk->GetMeta(a_RelX, a_RelY, a_RelZ)
);
BLOCKTYPE MyBlock; NIBBLETYPE MyMeta;
a_Chunk->GetBlockTypeMeta(a_RelX, a_RelY, a_RelZ, MyBlock, MyMeta);
if (!IsAnyFluidBlock(MyBlock))
{
// Can happen - if a block is scheduled for simulating and gets replaced in the meantime.
FLOG(" BadBlockType exit");
return;
}
// When in contact with water, lava should harden
if (HardenBlock(a_Chunk, a_RelX, a_RelY, a_RelZ, MyBlock, MyMeta))
{
// Block was changed, bail out
return;
}
if (MyMeta != 0)
{
// Source blocks aren't checked for tributaries, others are.
if (CheckTributaries(a_Chunk, a_RelX, a_RelY, a_RelZ, MyMeta))
{
// Has no tributary, has been decreased (in CheckTributaries()),
// no more processing needed (neighbors have been scheduled by the decrease)
FLOG(" CheckTributaries exit");
return;
}
}
// New meta for the spreading to neighbors:
// If this is a source block or was falling, the new meta is just the falloff
// Otherwise it is the current meta plus falloff (may be larger than max height, will be checked later)
NIBBLETYPE NewMeta = ((MyMeta == 0) || ((MyMeta & 0x08) != 0)) ? m_Falloff : (MyMeta + m_Falloff);
bool SpreadFurther = true;
if (a_RelY > 0)
{
BLOCKTYPE Below = a_Chunk->GetBlock(a_RelX, a_RelY - 1, a_RelZ);
if (IsPassableForFluid(Below) || IsBlockLava(Below) || IsBlockWater(Below))
{
// Spread only down, possibly washing away what's there or turning lava to stone / cobble / obsidian:
SpreadToNeighbor(a_Chunk, a_RelX, a_RelY - 1, a_RelZ, 8);
// Source blocks spread both downwards and sideways
if (MyMeta != 0)
{
SpreadFurther = false;
}
}
// If source creation is on, check for it here:
else if (
(m_NumNeighborsForSource > 0) && // Source creation is on
(MyMeta == m_Falloff) && // Only exactly one block away from a source (fast bail-out)
!IsPassableForFluid(Below) && // Only exactly 1 block deep
CheckNeighborsForSource(a_Chunk, a_RelX, a_RelY, a_RelZ) // Did we create a source?
)
{
// We created a source, no more spreading is to be done now
// Also has been re-scheduled for ticking in the next wave, so no marking is needed
return;
}
}
if (SpreadFurther && (NewMeta < 8))
{
// Spread to the neighbors:
Spread(a_Chunk, a_RelX, a_RelY, a_RelZ, NewMeta);
}
// Mark as processed:
a_Chunk->FastSetBlock(a_RelX, a_RelY, a_RelZ, m_StationaryFluidBlock, MyMeta);
}
