void GroupGame::play()
{
clear();
startGame();
QModeStart startInfo(0, tr("Grouping Game"));
QVBoxLayout *layout = startInfo.mainLayout();
QFormLayout form;
layout->addLayout(&form);
QSpinBox groupLength;
m_groupLengthSpinBox = &groupLength;
groupLength.setValue(int(m_goodGuesses - m_badGuesses / GROUPLENGTH_WEIGHT));
if (groupLength.value() < 1)
groupLength.setValue(1);
groupLength.setMaximum(m_WPM);
form.addRow(tr("Starting Group Length:"), &groupLength);
QSpinBox WPM;
WPM.setValue(m_WPM);
connect(&WPM, SIGNAL(valueChanged(int)), this, SLOT(limitLength(int)));
form.addRow(tr("Starting WPM:"), &WPM);
if (startInfo.exec() == QDialog::Accepted) {
m_goodGuesses = GROUPLENGTH_WEIGHT * (groupLength.value() - 1);
m_WPM = WPM.value();
m_morse->createTones(m_WPM);
startNextGroup();
}
m_groupLengthSpinBox = 0;
}
void Program::run(ProgramType prog)
{
if(!Calibrate::check())
return;
dischargeOutputCapacitor();
programType = prog;
setupProgramType(prog);
stopReason = NULL;
programState = Info;
SerialLog::powerOn();
AnalogInputs::powerOn();
if(startInfo()) {
programState = InProgress;
Monitor::powerOn();
Screen::powerOn();
Strategy::exitImmediately = false;
Buzzer::soundStartProgram();
runWithoutInfo(programType);
Monitor::powerOff();
}
AnalogInputs::powerOff();
SerialLog::powerOff();
Screen::powerOff();
}
std::unique_ptr<StartInfo> Menu::run()
{
sf::RenderWindow& window(config.window);
toGetUserName();
bgMusic = &config.musMan.get("Down1.ogg");
bgMusic->setLoop(true);
bgMusic->play();
while (window.isOpen() && !done)
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
gui.handleEvent(event);
config.cursor.update();
}
//if the state is lobby, update the lobby
if (state == Menu::STATE::multiplayer_lobby)
{
lobbyPtr->update();
done = lobbyPtr->isDone();
}
window.clear();
draw();
window.display();
}
std::unique_ptr<StartInfo> startInfo(nullptr);
//if the Menu exit with game starting, return Startinfo. else, return an null pointer.
if (lobbyPtr)
{
startInfo = lobbyPtr->getStartInfo();
}
bgMusic->stop();
return startInfo;
}
///////////////////////////////////////////////////////////////////////////////////////////
// FindAllStrips()
//
// Does the stripification, puts output strips into vector allStrips
//
// Works by setting runnning a number of experiments in different areas of the mesh, and
// accepting the one which results in the longest strips. It then accepts this, and moves
// on to a different area of the mesh. We try to jump around the mesh some, to ensure that
// large open spans of strips get generated.
//
void NvStripifier::FindAllStrips(NvStripInfoVec &allStrips,
NvFaceInfoVec &allFaceInfos,
NvEdgeInfoVec &allEdgeInfos,
int numSamples){
// the experiments
int experimentId = 0;
int stripId = 0;
bool done = false;
int loopCtr = 0;
while (!done)
{
loopCtr++;
//
// PHASE 1: Set up numSamples * numEdges experiments
//
NvStripInfoVec *experiments = new NvStripInfoVec [numSamples * 6];
int experimentIndex = 0;
std::set <NvFaceInfo*> resetPoints;
for (int i = 0; i < numSamples; i++)
{
// Try to find another good reset point.
// If there are none to be found, we are done
NvFaceInfo *nextFace = FindGoodResetPoint(allFaceInfos, allEdgeInfos);
if (nextFace == NULL){
done = true;
break;
}
// If we have already evaluated starting at this face in this slew
// of experiments, then skip going any further
else if (resetPoints.find(nextFace) != resetPoints.end()){
continue;
}
// trying it now...
resetPoints.insert(nextFace);
// otherwise, we shall now try experiments for starting on the 01,12, and 20 edges
assert(nextFace->m_stripId < 0);
// build the strip off of this face's 0-1 edge
NvEdgeInfo *edge01 = FindEdgeInfo(allEdgeInfos, nextFace->m_v0, nextFace->m_v1);
NvStripInfo *strip01 = new NvStripInfo(NvStripStartInfo(nextFace, edge01, true), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip01);
// build the strip off of this face's 1-0 edge
NvEdgeInfo *edge10 = FindEdgeInfo(allEdgeInfos, nextFace->m_v0, nextFace->m_v1);
NvStripInfo *strip10 = new NvStripInfo(NvStripStartInfo(nextFace, edge10, false), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip10);
// build the strip off of this face's 1-2 edge
NvEdgeInfo *edge12 = FindEdgeInfo(allEdgeInfos, nextFace->m_v1, nextFace->m_v2);
NvStripInfo *strip12 = new NvStripInfo(NvStripStartInfo(nextFace, edge12, true), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip12);
// build the strip off of this face's 2-1 edge
NvEdgeInfo *edge21 = FindEdgeInfo(allEdgeInfos, nextFace->m_v1, nextFace->m_v2);
NvStripInfo *strip21 = new NvStripInfo(NvStripStartInfo(nextFace, edge21, false), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip21);
// build the strip off of this face's 2-0 edge
NvEdgeInfo *edge20 = FindEdgeInfo(allEdgeInfos, nextFace->m_v2, nextFace->m_v0);
NvStripInfo *strip20 = new NvStripInfo(NvStripStartInfo(nextFace, edge20, true), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip20);
// build the strip off of this face's 0-2 edge
NvEdgeInfo *edge02 = FindEdgeInfo(allEdgeInfos, nextFace->m_v2, nextFace->m_v0);
NvStripInfo *strip02 = new NvStripInfo(NvStripStartInfo(nextFace, edge02, false), stripId++, experimentId++);
experiments[experimentIndex++].push_back(strip02);
}
//
// PHASE 2: Iterate through that we setup in the last phase
// and really build each of the strips and strips that follow to see how
// far we get
//
int numExperiments = experimentIndex;
for (int i = 0; i < numExperiments; i++){
// get the strip set
// build the first strip of the list
experiments[i][0]->Build(allEdgeInfos, allFaceInfos);
int experimentId = experiments[i][0]->m_experimentId;
NvStripInfo *stripIter = experiments[i][0];
NvStripStartInfo startInfo(NULL, NULL, false);
while (FindTraversal(allFaceInfos, allEdgeInfos, stripIter, startInfo)){
// create the new strip info
stripIter = new NvStripInfo(startInfo, stripId++, experimentId);
// build the next strip
stripIter->Build(allEdgeInfos, allFaceInfos);
// add it to the list
experiments[i].push_back(stripIter);
}
}
//
// Phase 3: Find the experiment that has the most promise
//
int bestIndex = 0;
double bestValue = 0;
for (int i = 0; i < numExperiments; i++)
{
const float avgStripSizeWeight = 1.0f;
const float numTrisWeight = 0.0f;
const float numStripsWeight = 0.0f;
float avgStripSize = AvgStripSize(experiments[i]);
float numStrips = (float) experiments[i].size();
float value = avgStripSize * avgStripSizeWeight + (numStrips * numStripsWeight);
//float value = 1.f / numStrips;
//float value = numStrips * avgStripSize;
if (value > bestValue)
{
bestValue = value;
bestIndex = i;
}
}
//
// Phase 4: commit the best experiment of the bunch
//
CommitStrips(allStrips, experiments[bestIndex]);
// and destroy all of the others
for (int i = 0; i < numExperiments; i++)
{
if (i != bestIndex)
{
int numStrips = experiments[i].size();
for (int j = 0; j < numStrips; j++)
{
NvStripInfo* currStrip = experiments[i][j];
//delete all bogus faces in the experiments
for (size_t k = 0; k < currStrip->m_faces.size(); ++k)
{
if(currStrip->m_faces[k]->m_bIsFake)
{
delete currStrip->m_faces[k], currStrip->m_faces[k] = NULL;
}
}
delete currStrip, currStrip = NULL, experiments[i][j] = NULL;
}
}
}
// delete the array that we used for all experiments
delete [] experiments;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// SplitUpStripsAndOptimize()
//
// Splits the input vector of strips (allBigStrips) into smaller, cache friendly pieces, then
// reorders these pieces to maximize cache hits
// The final strips are output through outStrips
//
void NvStripifier::SplitUpStripsAndOptimize(NvStripInfoVec &allStrips, NvStripInfoVec &outStrips,
NvEdgeInfoVec& edgeInfos, NvFaceInfoVec& outFaceList)
{
int threshold = cacheSize;
NvStripInfoVec tempStrips;
//split up strips into threshold-sized pieces
for(size_t i = 0; i < allStrips.size(); i++)
{
NvStripInfo* currentStrip;
NvStripStartInfo startInfo(NULL, NULL, false);
int actualStripSize = 0;
for(size_t j = 0; j < allStrips[i]->m_faces.size(); ++j)
{
if( !IsDegenerate(allStrips[i]->m_faces[j]) )
actualStripSize++;
}
if(actualStripSize /*allStrips[i]->m_faces.size()*/ > threshold)
{
int numTimes = actualStripSize /*allStrips[i]->m_faces.size()*/ / threshold;
int numLeftover = actualStripSize /*allStrips[i]->m_faces.size()*/ % threshold;
int degenerateCount = 0;
int j = 0;
for(; j < numTimes; j++)
{
currentStrip = new NvStripInfo(startInfo, 0, -1);
int faceCtr = j*threshold + degenerateCount;
bool bFirstTime = true;
while(faceCtr < threshold+(j*threshold)+degenerateCount)
{
if(IsDegenerate(allStrips[i]->m_faces[faceCtr]))
{
degenerateCount++;
//last time or first time through, no need for a degenerate
if( (((faceCtr + 1) != threshold+(j*threshold)+degenerateCount) ||
((j == numTimes - 1) && (numLeftover < 4) && (numLeftover > 0))) &&
!bFirstTime)
{
currentStrip->m_faces.push_back(allStrips[i]->m_faces[faceCtr++]);
}
else
{
//but, we do need to delete the degenerate, if it's marked fake, to avoid leaking
if(allStrips[i]->m_faces[faceCtr]->m_bIsFake)
{
delete allStrips[i]->m_faces[faceCtr], allStrips[i]->m_faces[faceCtr] = NULL;
}
++faceCtr;
}
}
else
{
currentStrip->m_faces.push_back(allStrips[i]->m_faces[faceCtr++]);
bFirstTime = false;
}
}
/*
for(int faceCtr = j*threshold; faceCtr < threshold+(j*threshold); faceCtr++)
{
currentStrip->m_faces.push_back(allStrips[i]->m_faces[faceCtr]);
}
*/
if(j == numTimes - 1) //last time through
{
if( (numLeftover < 4) && (numLeftover > 0) ) //way too small
{
//just add to last strip
int ctr = 0;
while(ctr < numLeftover)
{
IsDegenerate( allStrips[i]->m_faces[faceCtr] ) ? ++degenerateCount : ++ctr;
currentStrip->m_faces.push_back(allStrips[i]->m_faces[faceCtr++]);
}
numLeftover = 0;
}
}
tempStrips.push_back(currentStrip);
}
int leftOff = j * threshold + degenerateCount;
if(numLeftover != 0)
{
currentStrip = new NvStripInfo(startInfo, 0, -1);
int ctr = 0;
bool bFirstTime = true;
while(ctr < numLeftover)
{
if( !IsDegenerate(allStrips[i]->m_faces[leftOff]) )
{
ctr++;
bFirstTime = false;
currentStrip->m_faces.push_back(allStrips[i]->m_faces[leftOff++]);
}
else if(!bFirstTime)
currentStrip->m_faces.push_back(allStrips[i]->m_faces[leftOff++]);
else
{
//don't leak
if(allStrips[i]->m_faces[leftOff]->m_bIsFake)
{
delete allStrips[i]->m_faces[leftOff], allStrips[i]->m_faces[leftOff] = NULL;
}
leftOff++;
}
}
/*
for(size_t k = 0; k < numLeftover; k++)
{
currentStrip->m_faces.push_back(allStrips[i]->m_faces[leftOff++]);
}
*/
tempStrips.push_back(currentStrip);
}
}
else
{
//we're not just doing a tempStrips.push_back(allBigStrips[i]) because
// this way we can delete allBigStrips later to free the memory
currentStrip = new NvStripInfo(startInfo, 0, -1);
for(size_t j = 0; j < allStrips[i]->m_faces.size(); j++)
currentStrip->m_faces.push_back(allStrips[i]->m_faces[j]);
tempStrips.push_back(currentStrip);
}
}
//add small strips to face list
NvStripInfoVec tempStrips2;
RemoveSmallStrips(tempStrips, tempStrips2, outFaceList);
outStrips.clear();
//screw optimization for now
// for(size_t i = 0; i < tempStrips.size(); ++i)
// outStrips.push_back(tempStrips[i]);
if(tempStrips2.size() != 0)
{
//Optimize for the vertex cache
VertexCache* vcache = new VertexCache(cacheSize);
float bestNumHits = -1.0f;
float numHits;
int bestIndex;
bool done = false;
int firstIndex = 0;
float minCost = 10000.0f;
for(size_t i = 0; i < tempStrips2.size(); i++)
{
int numNeighbors = 0;
//find strip with least number of neighbors per face
for(size_t j = 0; j < tempStrips2[i]->m_faces.size(); j++)
{
numNeighbors += NumNeighbors(tempStrips2[i]->m_faces[j], edgeInfos);
}
float currCost = (float)numNeighbors / (float)tempStrips2[i]->m_faces.size();
if(currCost < minCost)
{
minCost = currCost;
firstIndex = i;
}
}
UpdateCacheStrip(vcache, tempStrips2[firstIndex]);
outStrips.push_back(tempStrips2[firstIndex]);
tempStrips2[firstIndex]->visited = true;
bool bWantsCW = (tempStrips2[firstIndex]->m_faces.size() % 2) == 0;
//this n^2 algo is what slows down stripification so much....
// needs to be improved
while(1)
{
bestNumHits = -1.0f;
//find best strip to add next, given the current cache
for(size_t i = 0; i < tempStrips2.size(); i++)
{
if(tempStrips2[i]->visited)
continue;
numHits = CalcNumHitsStrip(vcache, tempStrips2[i]);
if(numHits > bestNumHits)
{
bestNumHits = numHits;
bestIndex = i;
}
else if(numHits >= bestNumHits)
{
//check previous strip to see if this one requires it to switch polarity
NvStripInfo *strip = tempStrips2[i];
int nStripFaceCount = strip->m_faces.size();
NvFaceInfo tFirstFace(strip->m_faces[0]->m_v0, strip->m_faces[0]->m_v1, strip->m_faces[0]->m_v2);
// If there is a second face, reorder vertices such that the
// unique vertex is first
if (nStripFaceCount > 1)
{
int nUnique = NvStripifier::GetUniqueVertexInB(strip->m_faces[1], &tFirstFace);
if (nUnique == tFirstFace.m_v1)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v1);
}
else if (nUnique == tFirstFace.m_v2)
{
SWAP(tFirstFace.m_v0, tFirstFace.m_v2);
}
// If there is a third face, reorder vertices such that the
// shared vertex is last
if (nStripFaceCount > 2)
{
int nShared0, nShared1;
GetSharedVertices(strip->m_faces[2], &tFirstFace, &nShared0, &nShared1);
if ( (nShared0 == tFirstFace.m_v1) && (nShared1 == -1) )
{
SWAP(tFirstFace.m_v1, tFirstFace.m_v2);
}
}
}
// Check CW/CCW ordering
if (bWantsCW == IsCW(strip->m_faces[0], tFirstFace.m_v0, tFirstFace.m_v1))
{
//I like this one!
bestIndex = i;
}
}
}
if(bestNumHits == -1.0f)
break;
tempStrips2[bestIndex]->visited = true;
UpdateCacheStrip(vcache, tempStrips2[bestIndex]);
outStrips.push_back(tempStrips2[bestIndex]);
bWantsCW = (tempStrips2[bestIndex]->m_faces.size() % 2 == 0) ? bWantsCW : !bWantsCW;
}
delete vcache;
}
}
forAllConstIter(labelHashSet, patchSet_, iter)
{
label patchi = iter.key();
const fvPatch& patch = mesh_.boundary()[patchi];
vectorField nf(patch.nf());
vectorField faceCellCentres(patch.patch().faceCellCentres());
forAll(patch, patchFacei)
{
label meshFacei = patch.start()+patchFacei;
// Find starting point on face (since faceCentre might not
// be on face-diagonal decomposition)
pointIndexHit startInfo
(
mappedPatchBase::facePoint
(
mesh_,
meshFacei,
polyMesh::FACE_DIAG_TRIS
)
);
point start;
if (startInfo.hit())
{
start = startInfo.hitPoint();
}
else
{
// Fallback: start tracking from neighbouring cell centre
start = faceCellCentres[patchFacei];
}
const point end = start-distance_*nf[patchFacei];
// Find tet for starting location
label celli = -1;
label tetFacei = -1;
label tetPtI = -1;
mesh_.findCellFacePt(start, celli, tetFacei, tetPtI);
// Add to cloud. Add originating face as passive data
cloud.addParticle
(
new findCellParticle
(
mesh_,
start,
celli,
tetFacei,
tetPtI,
end,
globalWalls.toGlobal(nPatchFaces) // passive data
)
);
nPatchFaces++;
}
///////////////////////////////////////////////////////////////////////////////////////////
// SplitUpStripsAndOptimize()
//
// Splits the input _vector_ of strips (allBigStrips) into smaller, cache friendly pieces, then
// reorders these pieces to maximize cache hits
// The final strips are output through outStrips
//
void NvStripifier::SplitUpStripsAndOptimize(NvStripInfoVec &allStrips, NvStripInfoVec &outStrips,
NvEdgeInfoVec& edgeInfos, NvFaceInfoVec& outFaceList)
{
int threshold = cacheSize;
NvStripInfoVec tempStrips;
//split up strips into threshold-sized pieces
int i;
for(i = 0; i < allStrips.size(); i++)
{
NvStripInfo* currentStrip;
NvStripStartInfo startInfo(NULL, NULL, false);
if(allStrips[i]->m_faces.size() > threshold)
{
int numTimes = allStrips[i]->m_faces.size() / threshold;
int numLeftover = allStrips[i]->m_faces.size() % threshold;
int j;
for(j = 0; j < numTimes; j++)
{
currentStrip = xr_new<NvStripInfo> (startInfo, 0, -1);
for(int faceCtr = j*threshold; faceCtr < threshold+(j*threshold); faceCtr++) {
currentStrip->m_faces.push_back(allStrips[i]->m_faces[faceCtr]);
}
tempStrips.push_back(currentStrip);
}
int leftOff = j * threshold;
if(numLeftover != 0)
{
currentStrip = xr_new<NvStripInfo> (startInfo, 0, -1);
for(int k = 0; k < numLeftover; k++)
{
currentStrip->m_faces.push_back(allStrips[i]->m_faces[leftOff++]);
}
tempStrips.push_back(currentStrip);
}
}
else
{
//we're not just doing a tempStrips.push_back(allBigStrips[i]) because
// this way we can _delete allBigStrips later to xr_free the memory
currentStrip = xr_new<NvStripInfo> (startInfo, 0, -1);
for(int j = 0; j < allStrips[i]->m_faces.size(); j++)
currentStrip->m_faces.push_back(allStrips[i]->m_faces[j]);
tempStrips.push_back(currentStrip);
}
}
//add small strips to face list
NvStripInfoVec tempStrips2;
RemoveSmallStrips(tempStrips, tempStrips2, outFaceList);
outStrips.clear();
if(tempStrips2.size() != 0)
{
//Optimize for the vertex cache
VertexCache* vcache = xr_new<VertexCache> (cacheSize);
float bestNumHits = -1.0f;
float numHits = 0;
int bestIndex = 0;
int firstIndex = 0;
float minCost = 10000.0f;
for(i = 0; i < tempStrips2.size(); i++)
{
int numNeighbors = 0;
//find strip with least number of neighbors per face
for(int j = 0; j < tempStrips2[i]->m_faces.size(); j++)
{
numNeighbors += NumNeighbors(tempStrips2[i]->m_faces[j], edgeInfos);
}
float currCost = (float)numNeighbors / (float)tempStrips2[i]->m_faces.size();
if(currCost < minCost)
{
minCost = currCost;
firstIndex = i;
}
}
UpdateCacheStrip(vcache, tempStrips2[firstIndex]);
outStrips.push_back(tempStrips2[firstIndex]);
tempStrips2[firstIndex]->visited = true;
//this n^2 algo is what slows down stripification so much....
// needs to be improved
while(1)
{
bestNumHits = -1.0f;
//find best strip to add next, given the current cache
for(int i = 0; i < tempStrips2.size(); i++)
{
if(tempStrips2[i]->visited)
continue;
numHits = CalcNumHitsStrip(vcache, tempStrips2[i]);
if(numHits > bestNumHits)
{
bestNumHits = numHits;
bestIndex = i;
}
}
if(bestNumHits == -1.0f)
break;
tempStrips2[bestIndex]->visited = true;
UpdateCacheStrip(vcache, tempStrips2[bestIndex]);
outStrips.push_back(tempStrips2[bestIndex]);
}
xr_delete(vcache);
}
}