void BaseSpline::addPoint(vec2& point )
{
m_controlPoints.push_back(point);
updatePoint();
m_controlPointsC = m_controlPoints.size();
}
bool DirtyListVisit::update(Feature* F)
{
if (DeletePass) return false;
if (!F->isDirty()) return false;
if (F->isDeleted()) return false;
if (Future.willBeErased(F) || Future.willBeAdded(F))
return EraseFromHistory;
if (!Future.updateNow(F))
return EraseFromHistory;
if (Node* Pt = dynamic_cast<Node*>(F))
{
if (Pt->isInteresting()) {
if (!(Pt->hasOSMId()) && notYetAdded(Pt))
return addPoint(Pt);
else
return updatePoint(Pt);
} else
return EraseFromHistory;
}
else if (Way* R = dynamic_cast<Way*>(F)) {
for (int i=0; i<R->size(); ++i)
if (!(R->get(i)->hasOSMId()) && notYetAdded(R->get(i)))
add(R->get(i));
return updateRoad(R);
} else if (Relation* Rel = dynamic_cast<Relation*>(F)) {
for (int i=0; i<Rel->size(); ++i)
if (!(Rel->get(i)->hasOSMId()) && notYetAdded(Rel->get(i)))
add(Rel->get(i));
return updateRelation(Rel);
}
return EraseFromHistory;
}
void boundaryArea::again()
{
for ( list<boundaryCurve>::iterator it( divisions ); it; ++it ) {
it->again();
}
updatePoint();
touch( -1 );
}
void CVVKeyPoint::updateImageSet(const QRectF &, const qreal &zoom)
{
imagePointInScene_=image_->mapImagePointToParent(
QPointF{ pt.x, pt.y });
bool isInVisibleArea=imagePointisVisible();
setVisible(show_ && isInVisibleArea);
emit updatePoint(isInVisibleArea);
zoom_ = zoom;
prepareGeometryChange();
// update();
}
void DrawBoxes()
{
for (int i =0 ;i<NUM_OF_BOXES;i++)
for (int j = 0;j<6;j++)
{
glPushMatrix();
glColor3d(boxesData[i*dataLength],boxesData[i*dataLength+1],boxesData[i*dataLength+2]);
glTranslated(boxesData[i*dataLength+3],boxesData[i*dataLength+4],boxesData[i*dataLength+5]);
DrawCraneCube();
glPopMatrix();
boxes[i] = updatePoint(boxesData[i*dataLength+3],boxesData[i*dataLength+4],boxesData[i*dataLength+5]);
}
}
//public
void IdleAnimation::update(float dt)
{
m_lines.erase(std::remove_if(m_lines.begin(), m_lines.end(),
[](const std::unique_ptr<LineSection>& line)
{
return line->dead();
}), m_lines.end());
for (auto& l : m_lines)
{
l->update(dt);
}
updatePoint(m_start, dt);
updatePoint(m_end, dt);
static sf::Clock timer;
if (timer.getElapsedTime().asSeconds() > spawnFrequency)
{
timer.restart();
m_lines.emplace_back(std::make_unique<LineSection>(m_start.position, m_end.position));
}
}
// add to project properties->configuration ->linker->input
//->additional dependences-> opengl32.lib;glu32.lib;glut.lib;
void init()
{
int i, j;
srand(time(0)); // set random values
for (i = 0; i<GSIZE; i++)
for (j = 0; j<GSIZE; j++)
ground[i][j] = 0;
hook = updatePoint(0, (stringLength - 2), 0);//(minMovePlarform + maxMovePlatform) / 2);
hookInitialStartX = hook.x;
hookInitialStartY = hook.y;
hookInitialStartZ = hook.z;
// set background color
glClearColor(0.61, 0.5, 0.9, 0);
glEnable(GL_DEPTH_TEST);
}
void PolygonCostCalculator::update( PointSet *pset )
{
if ( pset->type == GEOS_POINT )
{
updatePoint( pset );
}
else
{
double rx, ry;
if ( pset->getDist( px, py, &rx, &ry ) < updateLinePoly( pset ) )
{
PointSet *point = new PointSet( ry, ry );
update( point );
delete point;
}
}
}
bool Reconstruction::refinePoint(const track &t,point3d &p) {
int32_t num_frames = t.pixels.size();
J = new FLOAT[6*num_frames];
p_observe = new FLOAT[2*num_frames];
p_predict = new FLOAT[2*num_frames];
int32_t iter=0;
Reconstruction::result result = UPDATED;
while (result==UPDATED) {
result = updatePoint(t,p,1,1e-5);
if (iter++ > 20 || result==CONVERGED)
break;
}
delete J;
delete p_observe;
delete p_predict;
if (result==CONVERGED)
return true;
else
return false;
}
bool Editor::run(IrrlichtDevice* irr_device){
// Irrlicht Device
device=irr_device;
driver = device->getVideoDriver();
smgr = device->getSceneManager();
guienv = device->getGUIEnvironment();
coli=smgr->getSceneCollisionManager();
device->setEventReceiver(this);
// Editor Settings
data=new ed_data();
data->snapping = true;
data->limiting = true;
data->type = TOOL_NODEB;
data->menu = NULL;
// Load editor
Load_Scene();
Load_UI();
// Create project
project = new Project();
project->nodes[0] = new Node(device,data);
MoveTarget(project->nodes[0]->getPosition());
// Set up window
device->setWindowCaption(convert((project->mod + stringc(" - The NodeBox Editor")).c_str()));
device->setResizable(true);
// Step data
unsigned int counter=0;
dimension2d<irr::u32> last_render_size = driver->getCurrentRenderTargetSize();
while (device->run()){
counter++;
driver->beginScene(true, true, irr::video::SColor(255,100,101,140));
int ResX = driver->getScreenSize().Width;
int ResY = driver->getScreenSize().Height;
if (isSplitScreen==true)
{
// Draw Camera 0
if (camera[0]){
smgr->setActiveCamera(camera[0]);
driver->setViewPort(rect<s32>(0,0,ResX/2,ResY/2));
smgr->drawAll();
}
// Draw Camera 1
if (camera[1]){
smgr->setActiveCamera(camera[1]);
driver->setViewPort(rect<s32>(ResX/2,0,ResX,ResY/2));
smgr->drawAll();
updatePoint(0,5);
}
// Draw Camera 2
if (camera[2]){
smgr->setActiveCamera(camera[2]);
driver->setViewPort(rect<s32>(0,ResY/2,ResX/2,ResY));
smgr->drawAll();
updatePoint(5,10);
}
// Draw Camera 3
if (camera[3]){
smgr->setActiveCamera(camera[3]);
driver->setViewPort(rect<s32>(ResX/2,ResY/2,ResX,ResY));
smgr->drawAll();
updatePoint(10,15);
}
// Draw GUI
driver->setViewPort(rect<s32>(0,0,ResX,ResY));
driver->draw2DLine(vector2d<irr::s32>(0,ResY/2),vector2d<irr::s32>(ResX,ResY/2),SColor(175,255,255,255));
driver->draw2DLine(vector2d<irr::s32>(0,ResY/2-1),vector2d<irr::s32>(ResX,ResY/2-1),SColor(175,255,255,255));
driver->draw2DLine(vector2d<irr::s32>(ResX/2,0),vector2d<irr::s32>(ResX/2,ResY),SColor(175,255,255,255));
driver->draw2DLine(vector2d<irr::s32>(ResX/2+1,0),vector2d<irr::s32>(ResX/2+1,ResY),SColor(175,255,255,255));
}else if (camera[currentWindow]){
smgr->setActiveCamera(camera[currentWindow]);
driver->setViewPort(rect<s32>(0,0,ResX,ResY));
smgr->drawAll();
updatePoint(0,15);
}
guienv->drawAll();
driver->endScene();
if ( driver->getCurrentRenderTargetSize() != last_render_size){
printf("Adjusting FOV to new screen size...\n");
last_render_size = driver->getCurrentRenderTargetSize();
camera[0]->setAspectRatio((float)driver->getScreenSize().Width/(float)driver->getScreenSize().Height);
// reset matrix
matrix4 projMat;
irr::f32 orth_w = (float)driver->getScreenSize().Width / (float)driver->getScreenSize().Height;
orth_w = 3 * orth_w;
projMat.buildProjectionMatrixOrthoLH(orth_w,3,1,100);
for (int i=1;i<4;i++){
if (camera[i]){
camera[i]->remove();
camera[i]=NULL;
}
}
// Remake cameras
camera[1]=smgr->addCameraSceneNode(target,vector3df(0,2,-0.01),vector3df(0,0,0));
camera[1]->setProjectionMatrix(projMat,true);
camera[2]=smgr->addCameraSceneNode(target,vector3df(0,0,-5),vector3df(0,0,0));
camera[2]->setProjectionMatrix(projMat,true);
camera[3]=smgr->addCameraSceneNode(target,vector3df(-5,0,0),vector3df(0,0,0));
camera[3]->setProjectionMatrix(projMat,true);
}
if (counter>500){
counter=0;
if (project->GetCurNode())
project->GetCurNode()->update();
}
}
return true;
}
void SegmentShape::setSecondPoint(const Vector2f& p)
{
updatePoint(p, 1);
}
void SegmentShape::setFirstPoint(const Vector2f& p)
{
updatePoint(p, 0);
}
//----------------------------------------------------
void ofxCvCoordWarpingGui::_mouseDragged(ofMouseEventArgs &e){
if (bCameraView) updatePoint(e.x, e.y, x, y, width*scale.x, height*scale.y);
}
bool cEditor::run(IrrlichtDevice* irr_device){
// Get Pointers
device=irr_device;
driver = device->getVideoDriver();
smgr = device->getSceneManager();
guienv = device->getGUIEnvironment();
data=new ed_data();
data->snapping = true;
data->limiting = true;
coli=smgr->getSceneCollisionManager();
device->setWindowCaption(L"The NodeBox Generator");
device->setResizable(true);
// Calculate Projection Matrix
matrix4 projMat;
irr::f32 orth_w = (float)driver->getScreenSize().Width / (float)driver->getScreenSize().Height;
orth_w = 3 * orth_w;
projMat.buildProjectionMatrixOrthoLH(orth_w,3,1,100);
// Add rotational camera
pivot=smgr->addEmptySceneNode(0,199);
pivot->setPosition(vector3df(0,0,0));
camera[0]=smgr->addCameraSceneNode(pivot,vector3df(0,0,-2),vector3df(0,0,0));
smgr->setActiveCamera(camera[0]);
pivot->setRotation(vector3df(25,-45,0));
// Add Topdown camera
camera[1]=smgr->addCameraSceneNode(NULL,vector3df(0,2,-0.01),vector3df(0,0,0));
camera[1]->setProjectionMatrix(projMat,true);
// Add front camera
camera[2]=smgr->addCameraSceneNode(NULL,vector3df(0,0,-5),vector3df(0,0,0));
camera[2]->setProjectionMatrix(projMat,true);
// Add side camera
camera[3]=smgr->addCameraSceneNode(NULL,vector3df(-5,0,0),vector3df(0,0,0));
camera[3]->setProjectionMatrix(projMat,true);
// Add Light
ILightSceneNode* light=smgr->addLightSceneNode(0,vector3df(25,50,0));
light->setLightType(ELT_POINT);
light->setRadius(2000);
// Add Plane
IMeshSceneNode* plane = smgr->addCubeSceneNode(1,0,-1,vector3df(0.5,-5.5,0.5),vector3df(0,0,0),vector3df(10,10,10));
plane->setMaterialTexture(0, driver->getTexture("texture_terrain.png"));
plane->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
plane->getMaterial(0).getTextureMatrix(0).setTextureScale(10,10);
// Add sky box
scene::IMeshSceneNode* skybox=smgr->addCubeSceneNode(50);
skybox->setMaterialTexture(0, driver->getTexture("sky.jpg"));
skybox->setMaterialFlag(video::EMF_BILINEAR_FILTER, false);
skybox->setMaterialFlag(video::EMF_LIGHTING,false);
smgr->getMeshManipulator()->flipSurfaces(skybox->getMesh());
plane_tri=smgr->createOctreeTriangleSelector(skybox->getMesh(),skybox);
//Setup Current Manager
nodes[0]=new cNode(device,data);
curId=0;
loadUI();
unsigned int counter=0;
while (device->run()){
counter++;
driver->beginScene(true, true, irr::video::SColor(255,100,101,140));
int ResX = driver->getScreenSize().Width;
int ResY = driver->getScreenSize().Height;
if (isSplitScreen==true)
{
// Draw Camera 0
if (camera[0]){
smgr->setActiveCamera(camera[0]);
driver->setViewPort(rect<s32>(0,0,ResX/2,ResY/2));
smgr->drawAll();
}
// Draw Camera 1
if (camera[1]){
smgr->setActiveCamera(camera[1]);
driver->setViewPort(rect<s32>(ResX/2,0,ResX,ResY/2));
smgr->drawAll();
updatePoint(0,4);
}
// Draw Camera 2
if (camera[2]){
smgr->setActiveCamera(camera[2]);
driver->setViewPort(rect<s32>(0,ResY/2,ResX/2,ResY));
smgr->drawAll();
updatePoint(4,8);
}
// Draw Camera 3
if (camera[3]){
smgr->setActiveCamera(camera[3]);
driver->setViewPort(rect<s32>(ResX/2,ResY/2,ResX,ResY));
smgr->drawAll();
updatePoint(8,12);
}
}else if (camera[currentWindow]){
smgr->setActiveCamera(camera[currentWindow]);
driver->setViewPort(rect<s32>(0,0,ResX,ResY));
smgr->drawAll();
}
driver->setViewPort(rect<s32>(0,0,ResX,ResY));
guienv->drawAll();
driver->endScene();
if (counter>500){
counter=0;
if (nodes[curId])
nodes[curId]->update();
}
}
return true;
}
std::size_t TextureReader::update( const Eigen::Vector3d& offset )
{
return updatePoint( offset ) ? 1 : 0;
}
bool guiQuad::updatePoint(float x, float y, float offsetX, float offsetY, float width, float height, bool noDistorsion){
if(!noDistorsion) {
updatePoint(x, y, offsetX, offsetY, width, height);
} else {
getScaledQuadPoints(width, height);
//nothing to update
if(selected == -1) return false;
if(width == 0 || height == 0){
//dangerous so we ignore :)
return false;
}
if( x < offsetX ) x = offsetX;
if( x > offsetX + width ) x = offsetX + width;
if( y < offsetY ) y = offsetY;
if( y > offsetY + height) y = offsetY + height;
//lets get it in range x(0 - width) y(0 - height)
float px = x - offsetX;
float py = y - offsetY;
if (!diag_v){
py = diag_a*px + diag_b;
if (py < 0) { py = 0; px = ((py - diag_b)/diag_a); }
else if (py > height) { py = height; px = ((py - diag_b)/diag_a); }
} else {
px = selX;
if (px < 0) { px = 0; py = diag_b; }
else if (px > width) { px = width; py = diag_a * width + diag_b; }
}
cout << "px = " << px << endl;
cout << "py = " << py << endl;
if (selected == 0) {
if (sideA_v == -1) {
sideA_b = py - (sideA_m * px);
cout << "sideA_b = " << sideA_b << endl;
if (sideB_v == -1) {
float temp_x;
if (sideB_m < 0 || sideB_m > 1) {
temp_x= (((sideA_m * temp_x) + sideA_b - sideB_b) / sideB_m) / width;
} else {
temp_x= (((sideB_m * temp_x) + sideB_b - sideA_b) / sideA_m) / width;
}
srcZeroToOne[1].x = temp_x;
srcZeroToOne[1].y = ((sideA_m * (srcZeroToOne[1].x * width)) + sideA_b)/height;
} else {
srcZeroToOne[1].y = ((sideA_m * (srcZeroToOne[1].x * width)) + sideA_b) / height;
}
} else {
srcZeroToOne[1].x = px/width;
srcZeroToOne[1].y = ((sideB_m * px) + sideB_b) / height;
}
if (sideD_v == -1) {
sideD_b = py - (sideD_m * px);
cout << "sideD_b = " << sideD_b << endl;
if (sideC_v == -1) {
float temp_x;
if (sideC_m < 0 || sideC_m > 1) {
temp_x = (((sideD_m * temp_x) + sideD_b - sideC_b) / sideC_m) / width;
} else {
temp_x = (((sideC_m * temp_x) + sideC_b - sideD_b) / sideD_m) / width;
}
srcZeroToOne[3].x = temp_x;
cout << "3x = " << temp_x * width << endl;
srcZeroToOne[3].y = ((sideD_m * (srcZeroToOne[3].x * width)) + sideD_b)/height;
cout << "3y = " << srcZeroToOne[3].y * height << endl;
} else {
srcZeroToOne[3].y = ((sideD_m * (srcZeroToOne[3].x * width)) + sideD_b) / height;
}
} else {
srcZeroToOne[3].x = px/width;
srcZeroToOne[3].y = ((sideC_m * px) + sideC_b) / height;
}
if (srcZeroToOne[1].x < 0) { srcZeroToOne[1].x = 0; }
else if (srcZeroToOne[1].x > 1) { srcZeroToOne[1].x = 1; }
if (srcZeroToOne[1].y < 0) { srcZeroToOne[1].y = 0; }
else if (srcZeroToOne[1].y > 1) { srcZeroToOne[1].y = 1; }
if (srcZeroToOne[3].x < 0) { srcZeroToOne[3].x = 0; }
else if (srcZeroToOne[3].x > 1) { srcZeroToOne[3].x = 1; }
if (srcZeroToOne[3].y < 0) { srcZeroToOne[3].y = 0; }
else if (srcZeroToOne[3].y > 1) { srcZeroToOne[3].y = 1; }
}
//now get in 0-1 range
px /= width;;
py /= height;
srcZeroToOne[selected].x = px;
srcZeroToOne[selected].y = py;
anchorPoint.x = (least(srcZeroToOne[1].x, srcZeroToOne[2].x) + greatest(srcZeroToOne[0].x, srcZeroToOne[3].x))/2;
anchorPoint.y = (least(srcZeroToOne[2].y, srcZeroToOne[3].y) + greatest(srcZeroToOne[0].y, srcZeroToOne[1].y))/2;
}
return true;
}
void ModelReader::update( const Eigen::Vector3d& offset )
{
updatePoint( offset );
}
/****************************************************************
* Main
****************************************************************/
int main(int argc, char **argv, char **envp)
{
struct pollfd fdset[5];
int nfds = 5;
int gpio_in_1_fd, gpio_out_1_fd, gpio_in_2_fd, gpio_out_2_fd, gpio_in_3_fd, gpio_out_3_fd, gpio_in_4_fd, gpio_out_4_fd;
int timeout, rc;
char buf[MAX_BUF];
int gpio_in_1, gpio_out_1, gpio_in_2, gpio_out_2, gpio_in_3, gpio_out_3, gpio_in_4, gpio_out_4;
int len;
// run with ./etch_gpio 50 115 51 49 20 48 7 112
if (argc < 9) {
printf("Usage: %s <gpio-in> <gpio-out>, ... , ... , ...\n\n");
printf("Interrupt driven output of four buttons, put in pairs of in/out\n");
exit(-1);
}
// Set the signal callback for Ctrl-C
signal(SIGINT, signal_handler);
gpio_in_1 = atoi(argv[1]);
gpio_out_1 = atoi(argv[2]);
gpio_export(gpio_in_1);
gpio_export(gpio_out_1);
gpio_set_dir(gpio_in_1, "in");
gpio_set_dir(gpio_out_1, "out");
gpio_set_edge(gpio_in_1, "falling");
gpio_in_1_fd = gpio_fd_open(gpio_in_1, O_RDONLY);
gpio_out_1_fd = gpio_fd_open(gpio_out_1, O_RDONLY);
gpio_in_2 = atoi(argv[3]);
gpio_out_2 = atoi(argv[4]);
gpio_export(gpio_in_2);
gpio_export(gpio_out_2);
gpio_set_dir(gpio_in_2, "in");
gpio_set_dir(gpio_out_2, "out");
gpio_set_edge(gpio_in_2, "falling");
gpio_in_2_fd = gpio_fd_open(gpio_in_2, O_RDONLY);
gpio_out_2_fd = gpio_fd_open(gpio_out_2, O_RDONLY);
gpio_in_3 = atoi(argv[5]);
gpio_out_3 = atoi(argv[6]);
gpio_export(gpio_in_3);
gpio_export(gpio_out_3);
gpio_set_dir(gpio_in_3, "in");
gpio_set_dir(gpio_out_3, "out");
gpio_set_edge(gpio_in_3, "falling");
gpio_in_3_fd = gpio_fd_open(gpio_in_3, O_RDONLY);
gpio_out_3_fd = gpio_fd_open(gpio_out_3, O_RDONLY);
gpio_in_4 = atoi(argv[7]);
gpio_out_4 = atoi(argv[8]);
gpio_export(gpio_in_4);
gpio_export(gpio_out_4);
gpio_set_dir(gpio_in_4, "in");
gpio_set_dir(gpio_out_4, "out");
gpio_set_edge(gpio_in_4, "falling");
gpio_in_4_fd = gpio_fd_open(gpio_in_4, O_RDONLY);
gpio_out_4_fd = gpio_fd_open(gpio_out_4, O_RDONLY);
timeout = POLL_TIMEOUT;
int grid[N][N];
int i, j;
for (i = 0; i < N; ++i)
{
for (j = 0; j < N; ++j)
{
grid[i][j] = 0;
}
}
point currentPoint = {.x = 0, .y = 0};
int currentDirection = NONE;
int isErasing = 0;
while (keepgoing) {
memset((void*)fdset, 0, sizeof(fdset));
fdset[0].fd = STDIN_FILENO;
fdset[0].events = POLLIN;
fdset[1].fd = gpio_in_1_fd;
fdset[1].events = POLLPRI;
fdset[2].fd = gpio_in_2_fd;
fdset[2].events = POLLPRI;
fdset[3].fd = gpio_in_3_fd;
fdset[3].events = POLLPRI;
fdset[4].fd = gpio_in_4_fd;
fdset[4].events = POLLPRI;
rc = poll(fdset, nfds, timeout);
if (rc < 0) {
printf("\npoll() failed!\n");
return -1;
}
if (fdset[1].revents & POLLPRI) {
lseek(fdset[1].fd, 0, SEEK_SET);
len = read(fdset[1].fd, buf, MAX_BUF);
unsigned int value;
if (buf[0] == '0') {
value = 0;
} else if (buf[0] == '1') {
value = 1;
}
gpio_set_value(gpio_out_1, value);
currentDirection = UP;
} else if (fdset[2].revents & POLLPRI) {
lseek(fdset[2].fd, 0, SEEK_SET);
len = read(fdset[2].fd, buf, MAX_BUF);
unsigned int value;
if (buf[0] == '0') {
value = 0;
} else if (buf[0] == '1') {
value = 1;
}
gpio_set_value(gpio_out_2, value);
currentDirection = DOWN;
} else if (fdset[3].revents & POLLPRI) {
lseek(fdset[3].fd, 0, SEEK_SET);
len = read(fdset[3].fd, buf, MAX_BUF);
unsigned int value;
if (buf[0] == '0') {
value = 0;
} else if (buf[0] == '1') {
value = 1;
}
gpio_set_value(gpio_out_3, value);
currentDirection = RIGHT;
} else if (fdset[4].revents & POLLPRI) {
lseek(fdset[4].fd, 0, SEEK_SET);
len = read(fdset[4].fd, buf, MAX_BUF);
unsigned int value;
if (buf[0] == '0') {
value = 0;
} else if (buf[0] == '1') {
value = 1;
}
gpio_set_value(gpio_out_4, value);
currentDirection = LEFT;
} else {
currentDirection = NONE;
}
if (fdset[0].revents & POLLIN) {
(void)read(fdset[0].fd, buf, 1);
//printf("\npoll() stdin read 0x%2.2X\n", (unsigned int) buf[0]);
if (buf[0]=='e') {
isErasing = !isErasing;
}
}
// Evaluate
currentPoint = updatePoint(currentDirection, currentPoint);
#ifdef DEBUG
printf("After Move: %d, %d\n", currentPoint.x, currentPoint.y);
#endif
updateBoardBasedOnCurrentPoint(grid, currentPoint, isErasing);
// Print the N by N matrix
printGrid(grid, isErasing);
}
gpio_fd_close(gpio_in_1_fd);
gpio_fd_close(gpio_out_1_fd);
gpio_fd_close(gpio_in_2_fd);
gpio_fd_close(gpio_out_2_fd);
gpio_fd_close(gpio_in_3_fd);
gpio_fd_close(gpio_out_3_fd);
gpio_fd_close(gpio_in_4_fd);
gpio_fd_close(gpio_out_4_fd);
return 0;
}
point updatePoint(int dir, point pt)
{
point returnPoint;
#ifdef DEBUG
printf("Before Move: %d, %d\n", pt.x, pt.y);
#endif
switch (dir) {
case UP:
#ifdef DEBUG
printf("Moving up\n");
#endif
if (pt.x > 0)
{
pt.x--;
}
// returnPoint = pt;
// break;
return pt;
case DOWN:
#ifdef DEBUG
printf("Moving down\n");
#endif
if (pt.x < N-1)
{
pt.x++;
}
// returnPoint = pt;
// break;
return pt;
case LEFT:
#ifdef DEBUG
printf("Moving left\n");
#endif
if (pt.y > 0)
{
pt.y--;
}
// returnPoint = pt;
// break;
return pt;
case RIGHT:
#ifdef DEBUG
printf("Moving right\n");
#endif
if (pt.y < N-1)
{
pt.y++;
}
// returnPoint = pt;
// break;
return pt;
case NONE:
#ifdef DEBUG
printf("Moving not at all\n");
#endif
// returnPoint = pt;
// break;
return pt;
default:
// Should never get here. Ever.
// printf("This message should never appear\n");
break;
// return returnPoint;
}
}
void ShowAll()
{
//double radious =
double rotate = ((rotate_control - 50) * 360 / 80);
double c = sqrt(hookInitialStartX*hookInitialStartX + hookInitialStartZ*hookInitialStartZ);
int delta = hookInitialStartY - ((stringLength - 2));
//update rotate
hook = updatePoint(c*sin(rotate*PI / 180), hookInitialStartY - delta, c*cos(rotate*PI / 180));
glEnable(GL_DEPTH_TEST);
// start of the transformations
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//DrawGround();
DrawCraneGround();
DrawBoxes();
glPushMatrix();
glTranslated(4, 1, 0);
glRotated(rotate, 0, 1, 0);
glTranslated(-4, -1, 0);
DrawCrane();
glPopMatrix();
// pick box when press hold
if (hold)
if (BoxInfocus != -1)
{
boxesData[BoxInfocus*dataLength +3] = hook.x+4;
boxesData[BoxInfocus*dataLength +4] = hook.y+12;
boxesData[BoxInfocus*dataLength +5] = hook.z;
}
else
BoxInfocus = hookIntersects();
if (realese)
{
if (BoxInfocus != -1)
{
boxFalling = BoxInfocus;
BoxInfocus = -1;
}
realese = false;
}
if(boxFalling != -1)
{
if (boxesData[boxFalling*dataLength +4] > 1 && !BoxIntersects())
boxesData[boxFalling*dataLength +4] -= fallSpeed;
else
boxFalling = -1;
}
// draw red point
glColor3d(0, 0, 1);
glPointSize(5);
glBegin(GL_POINTS);
glVertex3d(hook.x + 4, hook.y + 12, hook.z);
glEnd();
}
bool DirtyListVisit::add(Feature* F)
{
if (DeletePass) return false;
if (F->isDeleted()) return false;
// TODO Needed to add children of updated imported features. Sure there is no advert cases?
//if (!F->isDirty()) return false;
// Allow "Force Upload" of OSM objects
//if (F->hasOSMId()) return false;
if (Future.willBeErased(F))
return EraseFromHistory;
for (int i=0; i<AlreadyAdded.size(); ++i)
if (AlreadyAdded[i] == F)
return EraseResponse[i];
bool x;
if (Node* Pt = CAST_NODE(F))
{
if (Pt->isInteresting())
{
if (F->hasOSMId())
x = updatePoint(Pt);
else
x = addPoint(Pt);
AlreadyAdded.push_back(F);
EraseResponse.push_back(x);
return x;
}
else
return EraseFromHistory;
}
else if (Way* R = dynamic_cast<Way*>(F))
{
for (int i=0; i<R->size(); ++i)
if (!R->getNode(i)->isVirtual())
if (!(R->get(i)->hasOSMId()) && notYetAdded(R->get(i)))
add(R->get(i));
if (F->hasOSMId())
x = updateRoad(R);
else
x = addRoad(R);
AlreadyAdded.push_back(F);
EraseResponse.push_back(x);
return x;
}
else if (Relation* Rel = dynamic_cast<Relation*>(F))
{
for (int i=0; i<Rel->size(); ++i)
if (!(Rel->get(i)->hasOSMId()) && notYetAdded(Rel->get(i)))
add(Rel->get(i));
if (F->hasOSMId())
x = updateRelation(Rel);
else
x = addRelation(Rel);
AlreadyAdded.push_back(F);
EraseResponse.push_back(x);
return x;
}
return EraseFromHistory;
}
void FightLayer::initCard(){
auto fightBackground = Sprite::create("textures/IMG_Background/fight_background.png");
auto cs = fightBackground->getContentSize();
_bgSize = cs;
_nFight = LayerColor::create(Color4B(255,0,0,0),cs.width,cs.height);
_nFight->setAnchorPoint(Point(0.5,0));
_animalNode = Node::create();
auto p = VisibleRect::topRight()-Point(cs.width,cs.height);
_nFight->setPosition(p.x/2,p.y/2);
_animalNode->setPosition(Point(cs.width/2,cs.height/2)+Point(p.x/2,p.y/2));
addChild(_nFight);
addChild(_animalNode);
auto node = Node::create();
node->setPosition(cs.width/2,cs.height/2);
node->addChild(fightBackground);
_nFight->addChild(node);
for(auto id=0;id<_myVec.size();id++){
auto myCard = _myVec.at(id);
auto scale = myCard->getScaleX();
node->addChild(myCard);
auto myAn = myCard->getAnimal()->getThisLayer();
auto dcp = myCard->getPosition();
auto dp = myAn->getPosition();
auto np = dcp + Point(0, dp.y*scale);
auto nd = Node::create();
myAn->setScale(scale);
myAn->setPosition(myAn->getPosition().x,0);
nd->addChild(myAn);
updatePoint(nd, np);
_animalNode->addChild(nd);
}
for(auto ic = 0;ic<_monsterVec.size();ic++){
auto msCard = _monsterVec.at(ic);
auto cScale = msCard->getScaleX();
node->addChild(msCard);
auto msAn = msCard->getAnimal()->getThisLayer();
auto cDcp = msCard->getPosition();
auto cDp = msAn->getPosition();
auto dNp = cDcp+Point(0,cDp.y*cScale);
auto cNd = Node::create();
msAn->setScale(cScale);
msAn->setPosition(msAn->getPositionX(),0);
cNd->addChild(msAn);
updatePoint(cNd, dNp);
_animalNode->addChild(cNd);
}
}
