void Renderer::renderLevelSetFunctionValuesToCanvas(const LevelSet& level_set)
{
int grid_size_x = level_set.sizeX();
int grid_size_y = level_set.sizeY();
MyFloat scale_x = _canvas.width() / (_x_max - _x_min);
MyFloat scale_y = _canvas.height() / (_y_max - _y_min);
MyFloat translate_x = 0.5 * (_x_min * _canvas.width());
MyFloat translate_y = 0.5 * (_y_min * _canvas.height());
// Cell size in pixels
MyFloat cell_size_x = level_set.deltaX() * scale_x;
MyFloat cell_size_y = level_set.deltaY() * scale_y;
_canvas.setLineColor(Color(1,1,1));
for (int j = 0; j < grid_size_y; ++j)
{
for (int i = 0; i < grid_size_x; ++i)
{
MyFloat value = level_set.value(i, j);
Color fill_color = Color(value, value, value);
_canvas.setFillColor(fill_color);
_canvas.fillRectangle(
- translate_x + i * cell_size_x,
- translate_y + j * cell_size_y,
- translate_x + (i + 1) * cell_size_x,
- translate_y + (j + 1) * cell_size_y);
}
}
}
void FluidRenderer::drawSurfaceTriangles() {
TriangleMesh *surface = _fluidsim->getFluidSurfaceTriangles();
LevelSet *levelset = _fluidsim->getLevelSet();
MACVelocityField *vfield = _fluidsim->getVelocityField();
_setTransforms();
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glShadeModel(GL_SMOOTH);
glBegin(GL_TRIANGLES);
float min = 0.35f;
float max = 1.5f;
glm::vec3 p1, p2, p3, n1, n2, n3;
for (unsigned int i = 0; i < surface->triangles.size(); i++) {
Triangle t = surface->triangles[i];
p1 = surface->vertices[t.tri[0]];
p2 = surface->vertices[t.tri[1]];
p3 = surface->vertices[t.tri[2]];
n1 = surface->normals[t.tri[0]];
n2 = surface->normals[t.tri[1]];
n3 = surface->normals[t.tri[2]];
float k = (float)levelset->getSurfaceCurvature(i);
glm::vec3 p = (p1 + p2 + p3) / 3.0f;
glm::vec3 n = glm::normalize((n1 + n2 + n3) / 3.0f);
glm::vec3 v = glm::normalize(vfield->evaluateVelocityAtPosition(p));
if (glm::dot(v, n) < 0.6) {
k = 0.0f;
}
k = fmin(k, max);
k = fmax(k, min);
float f = (k - min) / (max - min);
glm::vec3 c = (1.0f - f)*glm::vec3(0.8, 0.8, 0.8) + f*glm::vec3(0.0, 1.0, 0.0);
glColor3d(c.x, c.y, c.z);
glNormal3f(n1.x, n1.y, n1.z);
glVertex3d(p1.x, p1.y, p1.z);
glNormal3f(n2.x, n2.y, n2.z);
glVertex3d(p2.x, p2.y, p2.z);
glNormal3f(n3.x, n3.y, n3.z);
glVertex3d(p3.x, p3.y, p3.z);
}
glNormal3f(0.0, 0.0, 1.0); // glColor stops working if I don't do this?
glEnd();
glDisable(GL_NORMALIZE);
_unsetTransforms();
}
void Grid::init( Setting& cfg){
mNx = cfg.lookup("cells.x");
mNy = cfg.lookup("cells.y");
mLx = cfg.lookup("size.x");
mLy = cfg.lookup("size.y");
// Boundary size, hardcoded
mBound = 2;
// Determine grid parameters
mDx = mLx/mNx;
mDy = mLy/mNy;
mSizeX = mNx + 2*mBound;
mSizeY = mNy + 2*mBound;
mStartX = mBound;
mStartY = mBound;
mEndX = mBound + mNx;
mEndY = mBound + mNy;
// Initialise pointers
int size = mSizeX * mSizeY;
pState = new vector<StateVector>(size);
pStateRef = new vector<StateVector>(size);
pFlux = new vector<FluxVector>(size);
pGeometry = new vector<BoundaryGeometry>(size);
// Initialise LevelSet
pLevelSet = new LevelSet(mNx,mNy,mBound,mDx,mDy,mLx,mLy);
pLevelSet->init();
return;
}
void EngineStage::activatePerformSingleTap(float x, float y)
{
switch (stageState)
{
case STAGE_STATE_INIT:
break;
case STAGE_STATE_RUNNING:
{
std::string queryGUI = hud->queryButtons(Vector2(x, y));
if (queryGUI == "powerup1")
player->performPowerUp("TractorBeam");
else if (queryGUI == "powerup2")
player->performPowerUp("Shields");
else if (queryGUI == "powerup3")
player->performPowerUp("TimeWarp");
else if (queryGUI == "toggle1")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
// Bad hack but
// Don't show 3-Back for multi-collection tasks of 1 or less.
if (player->getLevelRequestRow() > 0)
player->setToggleBack(0);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "toggle2")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
player->setToggleBack(1);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "toggle3")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
player->setToggleBack(2);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "toggle4")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
player->setToggleBack(3);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "pause")
{
setPause(true);
stageState = STAGE_STATE_PROMPT;
}
break;
}
case STAGE_STATE_PAUSE:
{
std::string queryGUI = hud->queryButtons(Vector2(x, y));
if (queryGUI == "toggle1")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
// Bad hack but
// Don't show 3-Back for multi-collection tasks of 1 or less.
if (player->getLevelRequestRow() > 0)
player->setToggleBack(0);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "toggle2")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
player->setToggleBack(1);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "toggle3")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
player->setToggleBack(2);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "toggle4")
{
if (tunnel && tunnel->isMultiCollectionTask())
{
player->setToggleBack(3);
tunnel->respondToToggleCheat();
}
}
else if (queryGUI == "pause")
{
setPause(true);
stageState = STAGE_STATE_PROMPT;
}
else if (queryGUI == "go")
{
stageState = STAGE_STATE_RUNNING;
setPause(false);
}
break;
}
case STAGE_STATE_PROMPT:
{
std::string queryGUI = hud->queryButtons(Vector2(x, y));
if (queryGUI == "resume")
{
// If game hasn't started yet, go back to init prompt
// Otherwise, go to gameplay
if (hud->isGoButtonActive())
{
stageState = STAGE_STATE_PAUSE;
if (player->hasTriggeredStartup() && player->getStartMusicTimer() <= 0.0)
player->playMusic();
}
else if (!tunnel->needsCleaning())
{
setPause(false);
stageState = STAGE_STATE_RUNNING;
}
}
else if (queryGUI == "next")
{
LevelSet* levels = player->getLevels();
int row = player->getLevelRequestRow();
int col = player->getLevelRequestCol();
int level = levels->getLevelNo(row, col);
int nlevel = ((level + 1) % NUM_TASKS) != 5 ? level + 1 : level + 2;
if (player->isLevelAvailable(nlevel))
{
row = levels->getLevelRow(nlevel);
col = levels->getLevelCol(nlevel);
player->setLevelRequest(row, col);
stageState = STAGE_STATE_INIT;
setPause(false);
OgreFramework::getSingletonPtr()->m_pSoundMgr->stopAllSounds();
}
}
else if (queryGUI == "restart")
{
stageState = STAGE_STATE_INIT;
setPause(false);
OgreFramework::getSingletonPtr()->m_pSoundMgr->stopAllSounds();
}
else if (queryGUI == "levelselect")
{
stageState = STAGE_STATE_DONE;
setPause(false);
OgreFramework::getSingletonPtr()->m_pSoundMgr->stopAllSounds();
}
break;
}
case STAGE_STATE_DONE:
break;
}
}
inline double levelset_workspace(int ii,int jj) const{ return pLevelSet->workspace(ii,jj);}
void HudStage::update(float elapsed)
{
std::string GUIToggleNumber = "General/GUIToggleTextNumber";
toggle1TextArt->setMaterialName(GUIToggleNumber + Util::toStringInt(tunnel->getNBack() % 10));
toggle2TextArt->setMaterialName(GUIToggleNumber + Util::toStringInt(Util::clamp((tunnel->getNBack() - 1) % 10, 0, tunnel->getNBack())));
toggle3TextArt->setMaterialName(GUIToggleNumber + Util::toStringInt(Util::clamp((tunnel->getNBack() - 2) % 10, 0, tunnel->getNBack())));
// toggle4 is always n-back 0
if (!tunnel->needsCleaning())
resumeButtonBackground->setMaterialName("General/ResumeButtonRound");
else
resumeButtonBackground->setMaterialName("General/ResumeButtonRoundGRAY");
LevelSet* levels = player->getLevels();
int levelRow = player->getLevelRequestRow();
int levelCol = player->getLevelRequestCol();
int level = levels->getLevelNo(levelRow, levelCol);
if (player->isLevelAvailable(level + 1))
nextButtonBackground->setMaterialName("General/NextButtonRound");
else
nextButtonBackground->setMaterialName("General/NextButtonRoundGRAY");
if( player->winFlag ) {
setOverlay(3, true);
tunnel->addToTimePenalty(2.0f);
float timeLeft = tunnel->getStageTime() - tunnel->getTotalElapsed() - tunnel->getTimePenalty();
if( timeLeft < 0.0f && timeLeft > -1.0f) player->setScore(player->getScore()+100.0f);
else if( timeLeft > 0.0f ) player->setScore(player->getScore()+200.0f);
label2->setColour(ColourValue(1.0,1.0,0.0));
label5->setColour(ColourValue(1.0,1.0,0.0));
label2->setCaption(Util::toStringInt(timeLeft));
endTallyTimeLabel->setCaption("Time " + Util::toStringInt(timeLeft));
label5->setCaption(Util::toStringInt(player->getScore()));
endTallyScoreLabel->setCaption(Util::toStringInt(player->getScore()) + " Score");
if( timeLeft <= 0.0f ) {
label2->setCaption("0");
endTallyTimeLabel->setCaption("Time 0");
tunnel->setCleaning(true);
player->winFlag = false;
}
return;
}
if( tunnel->isDone() ) return;
float timeLeft = fmax(tunnel->getStageTime() - tunnel->getTotalElapsed() - tunnel->getTimePenalty(), 0.0f);
label1->setCaption(globals.messageBig);
Ogre::ColourValue fontColor = timeLeft <= 0.0 ? ColourValue(1.0, 0.0, 0.0) : ColourValue(1.0, 1.0, 1.0);
label2->setColour(fontColor);
label2->setCaption(Util::toStringInt(timeLeft));
if (tunnel->getMode() == STAGE_MODE_RECESS)
label3->setCaption(Util::toStringInt(tunnel->getPercentComplete() * 100) + "%");
else
label3->setCaption("");
label4->setCaption(Util::toStringInt(player->getBaseSpeed()));
if (player->hasTriggeredStartup())
{
speedSlider->setBallDestination(player->getBaseSpeed());
speedSlider->update(elapsed);
}
speedSlider->adjust();
label5->setCaption(Util::toStringInt(player->getScore()));
label6->setCaption(globals.message);
label7->setCaption("");
if( player->isPowerUpActive("TimeWarp") ) {
TimeWarp* t = (TimeWarp*)player->getPowerUpPtr("TimeWarp");
if( t->zoomIn == 0 ) {
setOverlay(2, false);
timeWarpLabel->setCharHeight(0.05 * FONT_SZ_MULT);
timeWarpContainer->setPosition(0.50, 0.15);
}
else if( t->zoomIn == 1 ) {
setOverlay(2, true);
timeWarpLabel->setCharHeight(timeWarpLabel->getCharHeight()-0.0005 * FONT_SZ_MULT);
//timeWarpContainer->setPosition(timeWarpContainer->getLeft()+0.001 * FONT_SZ_MULT, timeWarpContainer->getTop()+0.0005 * FONT_SZ_MULT);
}
else {
setOverlay(2, true);
label2->setColour(ColourValue(1.0,1.0,0.0));
label2->setCharHeight(0.030 * FONT_SZ_MULT);
}
std::string val;
if( t->currentTimeVal < 10 ) val = " "+Util::toStringInt(t->currentTimeVal);
else val = Util::toStringInt(t->currentTimeVal);
timeWarpLabel->setCaption("+" + val + " Seconds");
}
else {
setOverlay(2, false);
label2->setColour(ColourValue(1.0,1.0,1.0));
label2->setCharHeight(0.025 * FONT_SZ_MULT);
}
// Set Progress Bar indicator position for the appropriate mode
float barWidth = barHP->getWidth();
if (tunnel->getMode() == STAGE_MODE_PROFICIENCY)
{
float HPRange = globals.HPPositiveLimit - globals.HPNegativeLimit + 1;
//indicator->setPosition(barHP->getLeft() + barWidth * player->getProgress(), indicator->getTop());
indicator->setPosition(barHP->getLeft() + barWidth * (player->getHP() - globals.HPNegativeLimit) / HPRange, indicator->getTop());
}
switch (player->getToggleBack())
{
case 0:
toggleIndicator->setPosition(0.897, 0.31);
break;
case 1:
toggleIndicator->setPosition(0.897, 0.43);
break;
case 2:
toggleIndicator->setPosition(0.897, 0.55);
break;
case 3:
toggleIndicator->setPosition(0.897, 0.67);
break;
}
if (player->isPowerUpAvailable("TractorBeam"))
buttons[BUTTON_POWERUP1].backgroundRef->setMaterialName("General/GUIPowerupButton2");
else
buttons[BUTTON_POWERUP1].backgroundRef->setMaterialName("General/GUIPowerupButtonBlank");
if (player->isPowerUpAvailable("Shields"))
buttons[BUTTON_POWERUP2].backgroundRef->setMaterialName("General/GUIPowerupButton0");
else
buttons[BUTTON_POWERUP2].backgroundRef->setMaterialName("General/GUIPowerupButtonBlank");
if (player->isPowerUpAvailable("TimeWarp"))
buttons[BUTTON_POWERUP3].backgroundRef->setMaterialName("General/GUIPowerupButton1");
else
buttons[BUTTON_POWERUP3].backgroundRef->setMaterialName("General/GUIPowerupButtonBlank");
std::vector<CollectionCriteria> criterias = tunnel->getCollectionCriteria();
for (int i = 0; i < collectionBar.size(); ++i)
{
if (i < criterias.size())
{
std::string scoreName = "General/GUICollection";
// For togglebacks
//if (criterias[i].nback <= 0)
// scoreName += Util::toStringInt(0);
//else
// scoreName += Util::toStringInt(Util::clamp(3 - (tunnel->getNBack() - criterias[i].nback), 0, 3));
// For just a single n-back and task
switch (tunnel->getPhase())
{
case 'A':
scoreName += "0";
break;
case 'B':
scoreName += "1";
break;
case 'C':
scoreName += "2";
break;
case 'D':
scoreName += "3";
break;
default:
scoreName += "0";
break;
}
if (criterias[i].collected)
scoreName += "Filled";
else
scoreName += "Blank";
collectionBar[i]->setMaterialName(scoreName);
}
else
{
collectionBar[i]->setMaterialName("General/GUICollectionGreyed");
}
}
}
std::vector<std::string> StrainMeasures::getLinearDistortion(double* wall_xi, unsigned int cnt, double power) {
unsigned int xdiscret = 25;
unsigned int ydiscret = 25;
//Create points of interest array
double **pointsOfInterest_x = new double*[xdiscret + 1];
double **pointsOfInterest_y = new double*[xdiscret + 1];
for (unsigned int i = 0; i <= xdiscret; i++) {
pointsOfInterest_x[i] = new double[ydiscret + 1];
pointsOfInterest_y[i] = new double[ydiscret + 1];
}
double delx = 1.0 / xdiscret;
double dely = 1.0 / ydiscret;
for (unsigned int xd = 0; xd <= xdiscret; xd++) {
double xinc = xd * delx;
if (xinc == 0.0)
xinc = 0.001;
if (xinc == 1.0)
xinc = 0.99;
for (unsigned int yd = 0; yd <= ydiscret; yd++) {
double yinc = yd * dely;
if (yinc == 0.0)
yinc = 0.001;
if (yinc == 1.0)
yinc = 0.99;
pointsOfInterest_x[xd][yd] = xinc;
pointsOfInterest_y[xd][yd] = yinc;
}
}
Cmiss_field_id principleStarinsField = Cmiss_field_module_find_field_by_name(field_module, "principal_strains");
double temp_array[3];
double coordinates[3];
long nan_count = 0;
std::vector<std::string> results;
std::vector<LevelSet*>* coordSets = new std::vector<LevelSet*>();
std::vector<LevelSet*>* deformSets = new std::vector<LevelSet*>();
for (unsigned int ls = 0; ls < cnt; ls++) {
coordSets->clear();
deformSets->clear();
for (unsigned int mt = 0; mt < numberOfModelFrames_; mt++) {
double time = ((double) mt) / (numberOfModelFrames_ - 1.0);
LevelSet* myCoordLevelSet = new LevelSet(num_elements, xdiscret + 1, ydiscret + 1);
LevelSet* myDeformLevelSet = new LevelSet(num_elements, xdiscret + 1, ydiscret + 1, 1);
Cmiss_field_cache_set_time(fieldCache, time);
nan_count = 0;
for (unsigned int xd = 0; xd <= xdiscret; xd++) {
for (unsigned int yd = 0; yd <= ydiscret; yd++) {
for (unsigned int elementId = 0; elementId < num_elements; elementId++) {
coordinates[0] = pointsOfInterest_x[xd][yd];
coordinates[1] = pointsOfInterest_y[xd][yd];
coordinates[2] = wall_xi[ls];
//std::cout<<coordinates[0]<<" "<<coordinates[1]<<" "<<coordinates[2]<<std::endl;
temp_array[0] = temp_array[1] = temp_array[2] = 0.0;
Cmiss_field_cache_set_mesh_location(fieldCache, elements[elementId], 3, coordinates);
Cmiss_field_evaluate_real(principleStarinsField, fieldCache, 3, temp_array);
double result = getLocalDeformation(temp_array, &nan_count);
myDeformLevelSet->setData(elementId, xd, yd, &result, 1);
Cmiss_field_evaluate_real(coordianteField, fieldCache, 3, temp_array);
myCoordLevelSet->setData(elementId, xd, yd, temp_array, 3);
}
}
}
coordSets->push_back(myCoordLevelSet);
deformSets->push_back(myDeformLevelSet);
}
std::stringstream ss;
unsigned int numpoints = coordSets->size();
for (unsigned int i = 0; i < numpoints; i++) {
LevelSet* myCoordLevelSet = coordSets->at(i);
LevelSet* myDeformLevelSet = deformSets->at(i);
ss << myDeformLevelSet->getLPSum(0, power) / myCoordLevelSet->getArea();
if (i < (numpoints - 1))
ss << ",";
delete myCoordLevelSet;
delete myDeformLevelSet;
}
results.push_back(ss.str());
}
//Clean up
delete deformSets;
delete coordSets;
for (unsigned int i = 0; i <= xdiscret; i++) {
delete[] pointsOfInterest_x[i];
delete[] pointsOfInterest_y[i];
}
delete[] pointsOfInterest_x;
delete[] pointsOfInterest_y;
Cmiss_field_destroy(&principleStarinsField);
return results;
}
