BYTE joymng_getstat(void) {
if (np2oscfg.JOYPAD1 == 1) {
#if 0
np2oscfg.JOYPAD1 |= 0x80; // ver0.28
#endif
joyflag = 0xff;
if (getCurrentPosition(hid_left, false)) {
joyflag &= ~JOY_LEFT_BIT;
}
else if (getCurrentPosition(hid_right, true)) {
joyflag &= ~JOY_RIGHT_BIT;
}
if (getCurrentPosition(hid_up, false)) {
joyflag &= ~JOY_UP_BIT;
}
else if (getCurrentPosition(hid_down, true)) {
joyflag &= ~JOY_DOWN_BIT;
}
if (getCurrenButton(hid_button2)) {
joyflag &= ~JOY_BTN2_BIT; // ver0.28
}
if (getCurrenButton(hid_button1)) {
joyflag &= ~JOY_BTN1_BIT; // ver0.28
}
}
return(joyflag);
}
//
// e x t r a c t S t r i n g
//
bool DinoLineBuffer::extractString(const DinoLineBufferPosition &startPosition,
const DinoLineBufferPosition &endPosition,
char *targetString){
// StartPosition invalid, probably because the line of the startPosition
// has already been overwritten, i.e. the string is too long
if (!isValidPosition(startPosition))
{
ogdf::strcpy(targetString, DinoLineBuffer::c_maxStringLength, "String too long!");
return false;
}
// EndPosition must be valid
OGDF_ASSERT(isValidPosition(endPosition))
// Remember original currentPosition
DinoLineBufferPosition originalCurrentPosition = getCurrentPosition();
// Begin at startPosition
setCurrentPosition(startPosition);
// Copy characters to tempString
int targetStringIndex = 0;
while (getCurrentPosition() != endPosition)
{
// Check if eof
OGDF_ASSERT(getCurrentCharacter() != EOF)
// Put character into targetString
targetString[targetStringIndex] = getCurrentCharacter();
++targetStringIndex;
// String too long
if (targetStringIndex >= DinoLineBuffer::c_maxStringLength - 1){
ogdf::strcpy(targetString, DinoLineBuffer::c_maxStringLength, "String too long!");
// Set back the original current position
setCurrentPosition(originalCurrentPosition);
return false;
}
// Move to next character
moveToNextCharacter();
} // Copy characters to tempString
// Set back the original current position
setCurrentPosition(originalCurrentPosition);
// Terminate string
targetString[targetStringIndex] = '\0';
return true;
} // extractString
bool CpuProfileInputStream::open(const gtString& path)
{
if (path.isEmpty())
{
return false;
}
// Check if file is already open
if (m_fileStream.isOpened())
{
if (path != m_path)
{
// Close and open a new file
close();
}
else
{
return true;
}
}
// Windows Note:
// The profile files are opened with UTF-8 encoding.
//
if (!m_fileStream.open(path.asCharArray(), WINDOWS_SWITCH(FMODE_TEXT("r, ccs=UTF-8"), FMODE_TEXT("rb"))))
{
return false;
}
// Set path name
m_path = path;
#if AMDT_BUILD_TARGET == AMDT_LINUX_OS
if (fwide(m_fileStream.getHandler(), 1) <= 0)
{
close();
return false;
}
// Note: For Linux
// Due to a bug in some version of gcc,
// we add this to make sure that we are
// starting from the beginning of the file.
m_fileStream.seekCurrentPosition(CrtFile::ORIGIN_BEGIN, 0);
#endif
getCurrentPosition(&m_bof);
// Get length of file
m_fileStream.seekCurrentPosition(CrtFile::ORIGIN_END, 0);
getCurrentPosition(&m_eof);
// Back to the beginning of file
setCurrentPosition(&m_bof);
return true;
}
void
SSLGamePlanner::runBackAndForth ()
{
pose_control.pose.clear ();
for (uint8_t i = 0; i < ssl::config::TEAM_CAPACITY; i++)
{
ssl_msgs::RobotPoseControl robot_pose_control;
if (team_global_state[i].state != ssl::OUT_OF_FOV)
{
if (curr_back_and_forth_state[i] == FORTH)
{
geometry_msgs::Point32 p = getCurrentPosition (team_, i);
double dx = target_poses[i].x - p.x;
double dy = target_poses[i].y - p.y;
double dist = sqrt (dx * dx + dy * dy);
if (dist < 0.02)
{
curr_back_and_forth_state[i] = BACK;
target_poses[i].x = -1.0;
target_poses[i].y = i * 0.65 - 1.0;
target_poses[i].theta = ssl::math::PI;
}
}
else
{
geometry_msgs::Point32 p = getCurrentPosition (team_, i);
double dx = target_poses[i].x - p.x;
double dy = target_poses[i].y - p.y;
double dist = sqrt (dx * dx + dy * dy);
if (dist < 0.02)
{
curr_back_and_forth_state[i] = FORTH;
target_poses[i].x = 1.0;
target_poses[i].y = i * 0.65 - 1.0;
target_poses[i].theta = 0.0;
}
}
robot_pose_control.id = i;
robot_pose_control.team = team_;
robot_pose_control.pose.x = target_poses[i].x;
robot_pose_control.pose.y = target_poses[i].y;
robot_pose_control.pose.theta = target_poses[i].theta;
robot_pose_control.flag_ball_obs = true;
target_poses[robot_pose_control.id] = robot_pose_control.pose;
pose_control.pose.push_back (robot_pose_control);
update_pose_control = true;
}
}
}
// the move function for the whole snake
inline void snake_head::move(float dy, float dx){
if(dx == 0 && dy == 0){
return;
}
//update the snake head position
vec3 pp = getCurrentPosition();
setPreviousPosition(pp);
vec3 cp = vec3(pp[0] + dx, pp[1] + dy, pp[2]);
setCurrentPosition(cp);
//update the first body position
pp = body[0].getCurrentPosition();
body[0].setPreviousPosition(pp);
cp = getPreviousPosition();
body[0].setCurrentPosition(cp);
//update the rest of body position if exist
for(int i = 1; i < numberOfBody; i++){
vec3 old_cp = body[i].getCurrentPosition();
body[i].setPreviousPosition(old_cp);
vec3 new_cp = body[i-1].getPreviousPosition();
body[i].setCurrentPosition(new_cp);
}
}
void
SSLGamePlanner::goToBall (uint8_t id, double orientation)
{
if (global_st.balls.size () > 0)
{
ssl_msgs::RobotPoseControl robot_pose_control;
// geometry_msgs::Point32 target_position;
geometry_msgs::Point32 current_position = getCurrentPosition (id);
geometry_msgs::Point32 target_position;
target_position.x = target_poses[id].x;
target_position.y = target_poses[id].y;
geometry_msgs::Point32 ball_position = global_st.balls[0].position;
double distance = sqrt (getSquaredDistance (current_position, target_position));
double ang = orientation + ssl::math::PI;
if (distance > BALL_PRE_POSE_OFFSET)
{
target_poses[id].x = ball_position.x + BALL_PRE_POSE_OFFSET * cos (ang);
target_poses[id].y = ball_position.y + BALL_PRE_POSE_OFFSET * sin (ang);
target_poses[id].theta = orientation;
robot_pose_control.flag_ball_obs = true;
}
else// if(distance > BALL_FETCH_OFFSET)
{
target_poses[id].x = ball_position.x + BALL_FETCH_OFFSET * cos (ang);
target_poses[id].y = ball_position.y + BALL_FETCH_OFFSET * sin (ang);
target_poses[id].theta = orientation;
robot_pose_control.flag_ball_obs = false;
}
robot_pose_control.pose.x = target_poses[id].x;
robot_pose_control.pose.y = target_poses[id].y;
robot_pose_control.pose.theta = target_poses[id].theta;
pose_control.pose.push_back (robot_pose_control);
}
}
// This is used to wait for the music in certain situations like especially the intro
// Note: the original game didn't do this, instead it just waited for certain amounts of time
// We do this, so that the intro graphics + music work together even on faster/slower hardware.
bool Music::waitUntilMSec(uint32 msecTarget, uint32 msecMax, uint32 additionalDelay, uint32 noMusicDelay) {
uint32 msecCurrent = 0;
if (!isPlaying()) {
return _vm->_events->delay(noMusicDelay, true);
}
while (1) {
if (!isPlaying()) { // Music is not playing anymore -> we are done
if (additionalDelay > 0) {
if (!_vm->_events->delay(additionalDelay, true))
return false;
}
return true;
}
msecCurrent = getCurrentPosition();
//warning("waitUntilMSec: %lx", msecCurrent);
if ((!msecMax) || (msecCurrent <= msecMax)) {
if (msecCurrent >= msecTarget) {
if (additionalDelay > 0) {
if (!_vm->_events->delay(additionalDelay, true))
return false;
}
return true;
}
}
if (!_vm->_events->delay(10, true))
return false;
}
}
NPC::Direction* NPC::changeDirection()
{
static std::random_device rd;
static std::mt19937 gen(rd());
std::vector<NPC::Direction*> directions = { &DirectionUp, &DirectionDown, &DirectionLeft, &DirectionRight };
uint32_t pcX, pcY, npcX, npcY;
std::tie(pcX, pcY) = m_board->getPlayerPosition();
std::tie(npcX, npcY) = getCurrentPosition();
if(pcX < npcX) {
directions.push_back(&DirectionLeft);
if(npcX - pcX > m_board->getFieldCountX() / 2) directions.push_back(&DirectionLeft);
} else {
directions.push_back(&DirectionRight);
if(pcX - npcX > m_board->getFieldCountX() / 2) directions.push_back(&DirectionRight);
}
if(pcY < npcY) {
directions.push_back(&DirectionUp);
if(npcY - pcY > m_board->getFieldCountY() / 2) directions.push_back(&DirectionUp);
} else {
directions.push_back(&DirectionDown);
if(pcY - npcY > m_board->getFieldCountY() / 2) directions.push_back(&DirectionDown);
}
std::shuffle(directions.begin(), directions.end(), gen);
return (m_direction = directions[0]);
}
void ofxAnimatableOfPoint::setPositionZ( float newZ ){
originalPoint_ = getCurrentPosition();
originalPoint_.z = newZ;
targetPoint_ = originalPoint_;
ofxAnimatable::reset();
}
sf::Vector2f LinearFlying::proceed(float seconds) {
currentDuration += seconds;
auto newX = initialPosition.x + (finalPosition.x - initialPosition.x) * (currentDuration / existenceDuration);
auto newY = initialPosition.y + (finalPosition.y - initialPosition.y) * (currentDuration / existenceDuration);
currentPosition = sf::Vector2f(newX, newY);
setObjectPosition(currentPosition);
return getCurrentPosition();
}
void CpuProfileInputStream::markPos(const gtString& mark)
{
if (!mark.isEmpty() && m_fileStream.isOpened() && !isEof())
{
fpos_t pos;
getCurrentPosition(&pos);
m_sectionMap.insert(SectionStreamPosMap::value_type(mark, pos));
}
}
void ofxAnimatableOfPoint::draw(){
ofPushMatrix();
ofPoint p = getCurrentPosition();
ofTranslate(p.x, p.y, p.z);
float s = 10.0f;
ofDrawRectangle( -s * 0.5f, -s * 0.5f, s, s );
ofPopMatrix();
}
void FB2BookReader::characterDataHandler(const char *text, std::size_t len) {
if ((len > 0) && (!myCurrentImageId.empty() || myModelReader.paragraphIsOpen())) {
std::string str(text, len);
if (!myCurrentImageId.empty()) {
if (myCurrentImageStart == -1) {
myCurrentImageStart = getCurrentPosition();
}
} else {
myModelReader.addData(str);
if (myInsideTitle) {
myModelReader.addContentsData(str);
}
}
}
}
void FB2CoverReader::endElementHandler(int tag) {
switch (tag) {
case _COVERPAGE:
myReadCoverPage = false;
break;
case _DESCRIPTION:
if (myImageId.empty()) {
interrupt();
}
break;
case _BINARY:
if (!myImageId.empty() && myImageStart >= 0) {
myImage = new ZLFileImage(myFile, "base64", myImageStart, getCurrentPosition() - myImageStart);
interrupt();
}
break;
}
}
void AutomatedMovingObject::paint(sf::RenderWindow* appWindow)
{
Point position = getCurrentPosition();
Point destination = getCurrentDestination();
sf::CircleShape destinationCircle(10,40);
sf::RectangleShape movingRectangle = sf::RectangleShape(sf::Vector2f(15,6));
movingRectangle.setRotation(movingObject.getDirection());
movingRectangle.setPosition(sf::Vector2f(position.x, position.y));
appWindow->draw(movingRectangle);
destinationCircle.setPosition(destination.x,destination.y);
destinationCircle.setFillColor(sf::Color(200,200,200,200));
destinationCircle.setPosition(destination.x, destination.y);
destinationCircle.setFillColor(sf::Color(230, 0, 0));
appWindow->draw(destinationCircle);
}
bool QMLManager::checkLocation(DiveObjectHelper *myDive, struct dive *d, QString location, QString gps)
{
bool diveChanged = false;
struct dive_site *ds = get_dive_site_by_uuid(d->dive_site_uuid);
if (myDive->location() != location) {
diveChanged = true;
ds = get_dive_site_by_uuid(create_dive_site(qPrintable(location), d->when));
d->dive_site_uuid = ds->uuid;
}
// now make sure that the GPS coordinates match - if the user changed the name but not
// the GPS coordinates, this still does the right thing as the now new dive site will
// have no coordinates, so the coordinates from the edit screen will get added
if (myDive->gps() != gps) {
double lat, lon;
if (parseGpsText(gps, &lat, &lon)) {
// there are valid GPS coordinates - just use them
setupDivesite(d, ds, lat, lon, qPrintable(myDive->location()));
diveChanged = true;
} else if (gps == GPS_CURRENT_POS) {
// user asked to use current pos
QString gpsString = getCurrentPosition();
if (gpsString != GPS_CURRENT_POS) {
if (parseGpsText(qPrintable(gpsString), &lat, &lon)) {
setupDivesite(d, ds, lat, lon, qPrintable(myDive->location()));
diveChanged = true;
}
} else {
appendTextToLog("couldn't get GPS location in time");
qDebug() << "still don't have a position - will need to implement some sort of callback";
}
} else {
// just something we can't parse, so tell the user
appendTextToLog(QString("wasn't able to parse gps string '%1'").arg(gps));
}
}
return diveChanged;
}
static RoutingStatus
doRouting (int column, int row, int screen) {
RoutingData routing;
#ifdef SIGUSR1
/* Set up the signal mask. */
sigemptyset(&routing.signalMask);
sigaddset(&routing.signalMask, SIGUSR1);
sigprocmask(SIG_UNBLOCK, &routing.signalMask, NULL);
#endif /* SIGUSR1 */
/* initialize the routing data structure */
routing.screenNumber = screen;
routing.rowBuffer = NULL;
routing.timeSum = ROUTING_TIMEOUT;
routing.timeCount = 1;
if (getCurrentPosition(&routing)) {
logRouting("from: [%d,%d]", routing.curx, routing.cury);
if (column < 0) {
adjustCursorVertically(&routing, 0, row);
} else {
if (adjustCursorVertically(&routing, -1, row) != CRR_FAIL)
if (adjustCursorHorizontally(&routing, 0, row, column) == CRR_NEAR)
if (routing.cury < row)
if (adjustCursorVertically(&routing, 1, routing.cury+1) != CRR_FAIL)
adjustCursorHorizontally(&routing, 0, row, column);
}
}
if (routing.rowBuffer) free(routing.rowBuffer);
if (routing.screenNumber != screen) return ROUTING_ERROR;
if (routing.cury != row) return ROUTING_WRONG_ROW;
if ((column >= 0) && (routing.curx != column)) return ROUTING_WRONG_COLUMN;
return ROUTING_DONE;
}
static int
awaitCursorMotion (RoutingData *routing, int direction) {
int oldx = (routing->oldx = routing->curx);
int oldy = (routing->oldy = routing->cury);
long timeout = routing->timeSum / routing->timeCount;
int moved = 0;
TimeValue start;
getCurrentTime(&start);
while (1) {
long time;
approximateDelay(ROUTING_INTERVAL);
time = millisecondsSince(&start) + 1;
{
int row = routing->cury + routing->verticalDelta;
int bestRow = row;
int bestLength = 0;
do {
ScreenCharacter buffer[routing->screenColumns];
if (!readScreenRow(routing, buffer, row)) break;
{
int before = routing->curx;
int after = before;
while (buffer[before].text == routing->rowBuffer[before].text)
if (--before < 0)
break;
while (buffer[after].text == routing->rowBuffer[after].text)
if (++after >= routing->screenColumns)
break;
{
int length = after - before - 1;
if (length > bestLength) {
bestRow = row;
if ((bestLength = length) == routing->screenColumns) break;
}
}
}
row -= direction;
} while ((row >= 0) && (row < routing->screenRows));
routing->verticalDelta = bestRow - routing->cury;
}
oldy = routing->cury;
oldx = routing->curx;
if (!getCurrentPosition(routing)) return 0;
if ((routing->cury != oldy) || (routing->curx != oldx)) {
logRouting("moved: [%d,%d] -> [%d,%d]",
oldx, oldy,
routing->curx, routing->cury);
if (!moved) {
moved = 1;
timeout = time * 2;
routing->timeSum += time * 8;
routing->timeCount += 1;
}
} else if (time > timeout) {
if (!moved) {
logRouting("timed out");
}
break;
}
}
return 1;
}
static int
awaitCursorMotion (RoutingData *routing, int direction, const CursorAxisEntry *axis) {
int moved = 0;
long int timeout = routing->timeSum / routing->timeCount;
TimeValue start;
int trgy = routing->cury;
int trgx = routing->curx;
routing->oldy = routing->cury;
routing->oldx = routing->curx;
axis->adjustCoordinate(&trgy, &trgx, direction);
getMonotonicTime(&start);
while (1) {
long int time;
TimeValue now;
int oldy;
int oldx;
approximateDelay(ROUTING_INTERVAL);
getMonotonicTime(&now);
time = millisecondsBetween(&start, &now) + 1;
{
int row = routing->cury + routing->verticalDelta;
int bestRow = row;
int bestLength = 0;
do {
ScreenCharacter buffer[routing->screenColumns];
if (!readScreenRow(routing, buffer, row)) break;
{
int before = routing->curx;
int after = before;
while (buffer[before].text == routing->rowBuffer[before].text)
if (--before < 0)
break;
while (buffer[after].text == routing->rowBuffer[after].text)
if (++after >= routing->screenColumns)
break;
{
int length = after - before - 1;
if (length > bestLength) {
bestRow = row;
if ((bestLength = length) == routing->screenColumns) break;
}
}
}
row -= direction;
} while ((row >= 0) && (row < routing->screenRows));
routing->verticalDelta = bestRow - routing->cury;
}
oldy = routing->cury;
oldx = routing->curx;
if (!getCurrentPosition(routing)) return 0;
if ((routing->cury != oldy) || (routing->curx != oldx)) {
logRouting("moved: [%d,%d] -> [%d,%d] (%dms)",
oldx, oldy, routing->curx, routing->cury, time);
if (!moved) {
moved = 1;
timeout = (time * 2) + 1;
routing->timeSum += time * 8;
routing->timeCount += 1;
}
if ((routing->cury == trgy) && (routing->curx == trgx)) break;
if (ROUTING_INTERVAL) {
start = now;
} else {
approximateDelay(1);
getMonotonicTime(&start);
}
} else if (time > timeout) {
if (!moved) logRouting("timed out: %ldms", timeout);
break;
}
}
return 1;
}
void FB2BookReader::endElementHandler(int tag) {
switch (tag) {
case _P:
myModelReader.endParagraph();
break;
case _V:
case _SUBTITLE:
case _TEXT_AUTHOR:
case _DATE:
myModelReader.popKind();
myModelReader.endParagraph();
break;
case _CITE:
myModelReader.popKind();
break;
case _SECTION:
if (myReadMainText) {
myModelReader.endContentsParagraph();
--mySectionDepth;
mySectionStarted = false;
} else {
myModelReader.unsetTextModel();
}
break;
case _TITLE:
myModelReader.exitTitle();
myModelReader.popKind();
myInsideTitle = false;
break;
case _POEM:
myInsidePoem = false;
break;
case _STANZA:
myModelReader.beginParagraph(ZLTextParagraph::AFTER_SKIP_PARAGRAPH);
myModelReader.endParagraph();
myModelReader.popKind();
break;
case _EPIGRAPH:
myModelReader.popKind();
break;
case _ANNOTATION:
myModelReader.popKind();
if (myBodyCounter == 0) {
myModelReader.insertEndOfSectionParagraph();
myModelReader.unsetTextModel();
}
break;
case _COVERPAGE:
if (myBodyCounter == 0) {
myInsideCoverpage = false;
myModelReader.insertEndOfSectionParagraph();
myModelReader.unsetTextModel();
}
break;
case _SUB:
myModelReader.addControl(SUB, false);
break;
case _SUP:
myModelReader.addControl(SUP, false);
break;
case _CODE:
myModelReader.addControl(CODE, false);
break;
case _STRIKETHROUGH:
myModelReader.addControl(STRIKETHROUGH, false);
break;
case _STRONG:
myModelReader.addControl(STRONG, false);
break;
case _EMPHASIS:
myModelReader.addControl(EMPHASIS, false);
break;
case _A:
myModelReader.addControl(myHyperlinkType, false);
break;
case _BINARY:
if (!myCurrentImageId.empty() && myCurrentImageStart != -1) {
myModelReader.addImage(myCurrentImageId, new ZLFileImage(
myModelReader.model().book()->file(),
"base64",
myCurrentImageStart,
getCurrentPosition() - myCurrentImageStart
));
}
myCurrentImageId.clear();
myCurrentImageStart = -1;
break;
case _BODY:
myModelReader.popKind();
myModelReader.unsetTextModel();
myReadMainText = false;
break;
default:
break;
}
}
status_t BnMediaPlayer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case DISCONNECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
disconnect();
return NO_ERROR;
} break;
case SET_DATA_SOURCE_URL: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
const char* url = data.readCString();
KeyedVector<String8, String8> headers;
int32_t numHeaders = data.readInt32();
for (int i = 0; i < numHeaders; ++i) {
String8 key = data.readString8();
String8 value = data.readString8();
headers.add(key, value);
}
reply->writeInt32(setDataSource(url, numHeaders > 0 ? &headers : NULL));
return NO_ERROR;
} break;
case SET_DATA_SOURCE_FD: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int fd = data.readFileDescriptor();
int64_t offset = data.readInt64();
int64_t length = data.readInt64();
reply->writeInt32(setDataSource(fd, offset, length));
return NO_ERROR;
}
case SET_DATA_SOURCE_STREAM: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<IStreamSource> source =
interface_cast<IStreamSource>(data.readStrongBinder());
reply->writeInt32(setDataSource(source));
return NO_ERROR;
}
case SET_VIDEO_SURFACETEXTURE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<ISurfaceTexture> surfaceTexture =
interface_cast<ISurfaceTexture>(data.readStrongBinder());
reply->writeInt32(setVideoSurfaceTexture(surfaceTexture));
return NO_ERROR;
} break;
case PREPARE_ASYNC: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(prepareAsync());
return NO_ERROR;
} break;
case START: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(start());
return NO_ERROR;
} break;
case STOP: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(stop());
return NO_ERROR;
} break;
case IS_PLAYING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
bool state;
status_t ret = isPlaying(&state);
reply->writeInt32(state);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case PAUSE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(pause());
return NO_ERROR;
} break;
case SEEK_TO: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(seekTo(data.readInt32()));
return NO_ERROR;
} break;
case GET_CURRENT_POSITION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getCurrentPosition(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case GET_DURATION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getDuration(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case RESET: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(reset());
return NO_ERROR;
} break;
case SET_AUDIO_STREAM_TYPE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAudioStreamType(data.readInt32()));
return NO_ERROR;
} break;
case SET_LOOPING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setLooping(data.readInt32()));
return NO_ERROR;
} break;
case SET_VOLUME: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
float leftVolume = data.readFloat();
float rightVolume = data.readFloat();
reply->writeInt32(setVolume(leftVolume, rightVolume));
return NO_ERROR;
} break;
case INVOKE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
status_t result = invoke(data, reply);
return result;
} break;
case SET_METADATA_FILTER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setMetadataFilter(data));
return NO_ERROR;
} break;
case GET_METADATA: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
bool update_only = static_cast<bool>(data.readInt32());
bool apply_filter = static_cast<bool>(data.readInt32());
const status_t retcode = getMetadata(update_only, apply_filter, reply);
reply->setDataPosition(0);
reply->writeInt32(retcode);
reply->setDataPosition(0);
return NO_ERROR;
} break;
case SET_AUX_EFFECT_SEND_LEVEL: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAuxEffectSendLevel(data.readFloat()));
return NO_ERROR;
} break;
case ATTACH_AUX_EFFECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(attachAuxEffect(data.readInt32()));
return NO_ERROR;
} break;
case SET_PARAMETER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int key = data.readInt32();
Parcel request;
if (data.dataAvail() > 0) {
request.appendFrom(
const_cast<Parcel *>(&data), data.dataPosition(), data.dataAvail());
}
request.setDataPosition(0);
reply->writeInt32(setParameter(key, request));
return NO_ERROR;
} break;
case GET_PARAMETER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
return getParameter(data.readInt32(), reply);
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
status_t BnMediaPlayer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case DISCONNECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
disconnect();
return NO_ERROR;
} break;
case SET_VIDEO_SURFACE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
sp<ISurface> surface = interface_cast<ISurface>(data.readStrongBinder());
reply->writeInt32(setVideoSurface(surface));
return NO_ERROR;
} break;
case PREPARE_ASYNC: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(prepareAsync());
return NO_ERROR;
} break;
case START: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(start());
return NO_ERROR;
} break;
case STOP: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(stop());
return NO_ERROR;
} break;
case IS_PLAYING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
bool state;
status_t ret = isPlaying(&state);
reply->writeInt32(state);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case PAUSE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(pause());
return NO_ERROR;
} break;
case SEEK_TO: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(seekTo(data.readInt32()));
return NO_ERROR;
} break;
case GET_CURRENT_POSITION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getCurrentPosition(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case GET_DURATION: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
int msec;
status_t ret = getDuration(&msec);
reply->writeInt32(msec);
reply->writeInt32(ret);
return NO_ERROR;
} break;
case RESET: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(reset());
return NO_ERROR;
} break;
case SET_AUDIO_STREAM_TYPE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAudioStreamType(data.readInt32()));
return NO_ERROR;
} break;
case SET_LOOPING: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setLooping(data.readInt32()));
return NO_ERROR;
} break;
case SET_VOLUME: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setVolume(data.readFloat(), data.readFloat()));
return NO_ERROR;
} break;
case INVOKE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
invoke(data, reply);
return NO_ERROR;
} break;
case SET_METADATA_FILTER: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setMetadataFilter(data));
return NO_ERROR;
} break;
case SUSPEND: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(suspend());
return NO_ERROR;
} break;
case RESUME: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(resume());
return NO_ERROR;
} break;
case GET_METADATA: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
const status_t retcode = getMetadata(data.readInt32(), data.readInt32(), reply);
reply->setDataPosition(0);
reply->writeInt32(retcode);
reply->setDataPosition(0);
return NO_ERROR;
} break;
case SET_AUX_EFFECT_SEND_LEVEL: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(setAuxEffectSendLevel(data.readFloat()));
return NO_ERROR;
} break;
case ATTACH_AUX_EFFECT: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(attachAuxEffect(data.readInt32()));
return NO_ERROR;
} break;
#ifdef OMAP_ENHANCEMENT
case REQUEST_CLONE_MODE: {
CHECK_INTERFACE(IMediaPlayer, data, reply);
reply->writeInt32(requestVideoCloneMode(data.readInt32()));
return NO_ERROR;
} break;
#endif
default:
return BBinder::onTransact(code, data, reply, flags);
}
}
geometry_msgs::Vector3
SSLPathPlanner::exePlanForRobot (const int& id)
{
geometry_msgs::Point curr_point = getCurrentPosition (id);
geometry_msgs::Point next_point;
next_point.x = next_target_poses[id].x;
next_point.y = next_target_poses[id].y;
next_point.z = 0.0;
geometry_msgs::Point target_point;
target_point.x = pose_control.pose[id].pose.x;
target_point.y = pose_control.pose[id].pose.y;
target_point.z = 0.0;
double curr_theta = team_state_[id].pose.theta;
// std::cout<<curr_theta<<std::endl;
double goal_theta = next_target_poses[id].theta;
// std::cout<<goal_theta<<std::endl;
double angular_diff = getAngularDifference (curr_theta, goal_theta);
// std::cout<<"angular_diff: "<<angular_diff/ssl::math::PI*180.0<<std::endl;
double angular_vel;
if (fabs (angular_diff) > ssl::math::PI / 2.0)
angular_vel = -MAX_ANGULAR_VEL * ssl::math::sign (angular_diff);
else
angular_vel = -MAX_ANGULAR_VEL * (angular_diff / (ssl::math::PI / 2.0));
// angular_vel = ssl::math::sign(angular_diff)*MAX_ANGULAR_VEL*(1-exp(-(fabs(angular_diff))));
markWaypoint (next_point, 0, id);
double dist = sqrt (getSquaredDistance (curr_point, next_point));
double ang = getAngleBetween (curr_point, next_point);
// if(dist<VERY_CRITICAL_DIST)
// {
// geometry_msgs::Vector3 v;
// double v_mag = dist/CRITICAL_DISTANCE * CRITICAL_LINEAR_VEL;
// v.x = v_mag * cos(goal_theta);
// v.y = v_mag * sin(goal_theta);
// return v;
// }
double vel_x = 0;
double vel_y = 0;
bool transit_pass = true;
if (next_point.x == target_point.x && next_point.y == target_point.y && next_point.z == target_point.z)
{
transit_pass = false;
}
if (dist > CRITICAL_DISTANCE)
{
vel_x = MAX_LINEAR_VEL * cos (ang);
vel_y = MAX_LINEAR_VEL * sin (ang);
//now consider obstacles around
}
else
{
if (!transit_pass)
{
if (dist < VERY_CRITICAL_DIST)
{
vel_x = CRITICAL_LINEAR_VEL * (dist / VERY_CRITICAL_DIST) * cos (ang);
vel_y = CRITICAL_LINEAR_VEL * (dist / VERY_CRITICAL_DIST) * sin (ang);
}
else
{
vel_x = MAX_LINEAR_VEL * (1 - exp (-dist * EXPONENT)) * cos (ang);
vel_y = MAX_LINEAR_VEL * (1 - exp (-dist * EXPONENT)) * sin (ang);
}
}
else
{
//TODO optimize this
vel_x = INT_LINEAR_VEL * (1 - exp (-dist * EXPONENT)) * cos (ang);
vel_y = INT_LINEAR_VEL * (1 - exp (-dist * EXPONENT)) * sin (ang);
}
}
geometry_msgs::Vector3 v = getCurrentVelocity (id);
// double curr_vel = getVelMagnitude(v);
// double curr_vel_ang= getVelAngle(v);
double des_acc_x = (vel_x - v.x) / ssl::config::TIME_STEP_SEC;
double des_acc_y = (vel_y - v.y) / ssl::config::TIME_STEP_SEC;
double des_acc = sqrt (des_acc_x * des_acc_x + des_acc_y * des_acc_y);
double des_acc_ang = atan2 (des_acc_y, des_acc_x);
if (des_acc > MAX_LINEAR_ACC)
des_acc = MAX_LINEAR_ACC;
des_acc_x = MAX_LINEAR_ACC * cos (des_acc_ang);
des_acc_y = MAX_LINEAR_ACC * sin (des_acc_ang);
v.x += des_acc_x * ssl::config::TIME_STEP_SEC * ACC_TUNING;
v.y += des_acc_y * ssl::config::TIME_STEP_SEC * ACC_TUNING;
double des_vel_ang = getVelAngle (v);
double des_vel_mag = getVelMagnitude (v);
if (des_vel_mag > MAX_LINEAR_VEL)
des_vel_mag = MAX_LINEAR_VEL;
v.x = des_vel_mag * cos (des_vel_ang);
v.y = des_vel_mag * sin (des_vel_ang);
tf::Vector3 tf_v;
tf::vector3MsgToTF (v, tf_v);
tf_v = tf_v.rotate (tf::Vector3 (0, 0, 1), -curr_theta);
tf::vector3TFToMsg (tf_v, v);
v.z = angular_vel;
return v;
}
int Game::run() {
// Initialize
if (!initializeGlfw()) {
return 1;
}
if (GLEW_OK != initializeGlew()) {
return 2;
}
initializeGl();
tileManager_->initialize(currentPos_);
options_ = tileManager_->getOptions();
ImGui_ImplGlfwGL3_Init(window_, true);
deltaTime_ = 0.0f; // Time between current and last frame
lastFrame_ = 0.0f; // Time at last frame
lastTime_ = 0.0f; // Time since last fps-"second"
frameCount_ = 0;
// Game loop
while (!glfwWindowShouldClose(window_)) {
// Calculate deltatime of current frame
GLfloat currentTime = glfwGetTime();
deltaTime_ = currentTime - lastFrame_;
lastFrame_ = currentTime;
// Check for events
glfwPollEvents();
// GUI
showGui();
// Move
do_movement(deltaTime_);
// Get current camera position
getCurrentPosition();
// Clear color- and depth buffer
glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Update and render tiles
tileManager_->update(currentPos_);
tileManager_->renderAll(deltaTime_, camera_.getViewMatrix());
// Render GUI
if (!guiClosed_) {
// ignore wireframe setting for gui
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
ImGui::Render();
glPolygonMode(GL_FRONT_AND_BACK, fillmode_);
}
// Swap the screen buffers
glfwSwapBuffers(window_);
}
// Clean up imgui
ImGui_ImplGlfwGL3_Shutdown();
// Clean up tiles
tileManager_->cleanUp();
// Terminate GLFW, clearing any resources allocated by GLFW.
glfwDestroyWindow(window_);
glfwTerminate();
return 0;
}
// update the dive and return the notes field, stripped of the HTML junk
void QMLManager::commitChanges(QString diveId, QString date, QString location, QString gps, QString duration, QString depth,
QString airtemp, QString watertemp, QString suit, QString buddy, QString diveMaster, QString weight, QString notes,
QString startpressure, QString endpressure, QString gasmix)
{
#define DROP_EMPTY_PLACEHOLDER(_s) if ((_s) == QLatin1Literal("--")) (_s).clear()
DROP_EMPTY_PLACEHOLDER(location);
DROP_EMPTY_PLACEHOLDER(duration);
DROP_EMPTY_PLACEHOLDER(depth);
DROP_EMPTY_PLACEHOLDER(airtemp);
DROP_EMPTY_PLACEHOLDER(watertemp);
DROP_EMPTY_PLACEHOLDER(suit);
DROP_EMPTY_PLACEHOLDER(buddy);
DROP_EMPTY_PLACEHOLDER(diveMaster);
DROP_EMPTY_PLACEHOLDER(weight);
DROP_EMPTY_PLACEHOLDER(gasmix);
DROP_EMPTY_PLACEHOLDER(startpressure);
DROP_EMPTY_PLACEHOLDER(endpressure);
DROP_EMPTY_PLACEHOLDER(notes);
#undef DROP_EMPTY_PLACEHOLDER
struct dive *d = get_dive_by_uniq_id(diveId.toInt());
// notes comes back as rich text - let's convert this into plain text
QTextDocument doc;
doc.setHtml(notes);
notes = doc.toPlainText();
if (!d) {
qDebug() << "don't touch this... no dive";
return;
}
bool diveChanged = false;
bool needResort = false;
invalidate_dive_cache(d);
if (date != get_dive_date_string(d->when)) {
diveChanged = needResort = true;
QDateTime newDate;
// what a pain - Qt will not parse dates if the day of the week is incorrect
// so if the user changed the date but didn't update the day of the week (most likely behavior, actually),
// we need to make sure we don't try to parse that
QString format(QString(prefs.date_format) + QChar(' ') + prefs.time_format);
if (format.contains(QLatin1String("ddd")) || format.contains(QLatin1String("dddd"))) {
QString dateFormatToDrop = format.contains(QLatin1String("ddd")) ? QStringLiteral("ddd") : QStringLiteral("dddd");
QDateTime ts;
QLocale loc = getLocale();
ts.setMSecsSinceEpoch(d->when * 1000L);
QString drop = loc.toString(ts.toUTC(), dateFormatToDrop);
format.replace(dateFormatToDrop, "");
date.replace(drop, "");
}
newDate = QDateTime::fromString(date, format);
if (!newDate.isValid()) {
qDebug() << "unable to parse date" << date << "with the given format" << format;
QRegularExpression isoDate("\\d+-\\d+-\\d+[^\\d]+\\d+:\\d+");
if (date.contains(isoDate)) {
newDate = QDateTime::fromString(date, "yyyy-M-d h:m:s");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date, "yy-M-d h:m:s");
if (newDate.isValid())
goto parsed;
}
QRegularExpression isoDateNoSecs("\\d+-\\d+-\\d+[^\\d]+\\d+");
if (date.contains(isoDateNoSecs)) {
newDate = QDateTime::fromString(date, "yyyy-M-d h:m");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date, "yy-M-d h:m");
if (newDate.isValid())
goto parsed;
}
QRegularExpression usDate("\\d+/\\d+/\\d+[^\\d]+\\d+:\\d+:\\d+");
if (date.contains(usDate)) {
newDate = QDateTime::fromString(date, "M/d/yyyy h:m:s");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date, "M/d/yy h:m:s");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date.toLower(), "M/d/yyyy h:m:sap");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date.toLower(), "M/d/yy h:m:sap");
if (newDate.isValid())
goto parsed;
}
QRegularExpression usDateNoSecs("\\d+/\\d+/\\d+[^\\d]+\\d+:\\d+");
if (date.contains(usDateNoSecs)) {
newDate = QDateTime::fromString(date, "M/d/yyyy h:m");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date, "M/d/yy h:m");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date.toLower(), "M/d/yyyy h:map");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date.toLower(), "M/d/yy h:map");
if (newDate.isValid())
goto parsed;
}
QRegularExpression leDate("\\d+\\.\\d+\\.\\d+[^\\d]+\\d+:\\d+:\\d+");
if (date.contains(leDate)) {
newDate = QDateTime::fromString(date, "d.M.yyyy h:m:s");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date, "d.M.yy h:m:s");
if (newDate.isValid())
goto parsed;
}
QRegularExpression leDateNoSecs("\\d+\\.\\d+\\.\\d+[^\\d]+\\d+:\\d+");
if (date.contains(leDateNoSecs)) {
newDate = QDateTime::fromString(date, "d.M.yyyy h:m");
if (newDate.isValid())
goto parsed;
newDate = QDateTime::fromString(date, "d.M.yy h:m");
if (newDate.isValid())
goto parsed;
}
}
parsed:
if (newDate.isValid()) {
// stupid Qt... two digit years are always 19xx - WTF???
// so if adding a hundred years gets you into something before a year from now...
// add a hundred years.
if (newDate.addYears(100) < QDateTime::currentDateTime().addYears(1))
newDate = newDate.addYears(100);
d->dc.when = d->when = newDate.toMSecsSinceEpoch() / 1000 + gettimezoneoffset(newDate.toMSecsSinceEpoch() / 1000);
} else {
qDebug() << "none of our parsing attempts worked for the date string";
}
}
struct dive_site *ds = get_dive_site_by_uuid(d->dive_site_uuid);
char *locationtext = NULL;
if (ds)
locationtext = ds->name;
if (!same_string(locationtext, qPrintable(location))) {
diveChanged = true;
// this is not ideal - and it's missing the gps information
// but for now let's just create a new dive site
ds = get_dive_site_by_uuid(create_dive_site(qPrintable(location), d->when));
d->dive_site_uuid = ds->uuid;
}
if (!gps.isEmpty()) {
QString gpsString = getCurrentPosition();
if (gpsString != QString("waiting for the next gps location")) {
qDebug() << "from commitChanges call to getCurrentPosition returns" << gpsString;
double lat, lon;
if (parseGpsText(qPrintable(gpsString), &lat, &lon)) {
struct dive_site *ds = get_dive_site_by_uuid(d->dive_site_uuid);
if (ds) {
ds->latitude.udeg = lat * 1000000;
ds->longitude.udeg = lon * 1000000;
} else {
degrees_t latData, lonData;
latData.udeg = lat;
lonData.udeg = lon;
d->dive_site_uuid = create_dive_site_with_gps("new site", latData, lonData, d->when);
}
qDebug() << "set up dive site with new GPS data";
}
} else {
qDebug() << "still don't have a position - will need to implement some sort of callback";
}
}
if (get_dive_duration_string(d->duration.seconds, tr("h:"), tr("min")) != duration) {
diveChanged = true;
int h = 0, m = 0, s = 0;
QRegExp r1(QStringLiteral("(\\d*)\\s*%1[\\s,:]*(\\d*)\\s*%2[\\s,:]*(\\d*)\\s*%3").arg(tr("h")).arg(tr("min")).arg(tr("sec")), Qt::CaseInsensitive);
QRegExp r2(QStringLiteral("(\\d*)\\s*%1[\\s,:]*(\\d*)\\s*%2").arg(tr("h")).arg(tr("min")), Qt::CaseInsensitive);
QRegExp r3(QStringLiteral("(\\d*)\\s*%1").arg(tr("min")), Qt::CaseInsensitive);
QRegExp r4(QStringLiteral("(\\d*):(\\d*):(\\d*)"));
QRegExp r5(QStringLiteral("(\\d*):(\\d*)"));
QRegExp r6(QStringLiteral("(\\d*)"));
if (r1.indexIn(duration) >= 0) {
h = r1.cap(1).toInt();
m = r1.cap(2).toInt();
s = r1.cap(3).toInt();
} else if (r2.indexIn(duration) >= 0) {
h = r2.cap(1).toInt();
m = r2.cap(2).toInt();
} else if (r3.indexIn(duration) >= 0) {
m = r3.cap(1).toInt();
} else if (r4.indexIn(duration) >= 0) {
h = r4.cap(1).toInt();
m = r4.cap(2).toInt();
s = r4.cap(3).toInt();
} else if (r5.indexIn(duration) >= 0) {
h = r5.cap(1).toInt();
m = r5.cap(2).toInt();
} else if (r6.indexIn(duration) >= 0) {
m = r6.cap(1).toInt();
}
d->dc.duration.seconds = d->duration.seconds = h * 3600 + m * 60 + s;
if (same_string(d->dc.model, "manually added dive")) {
free(d->dc.sample);
d->dc.sample = 0;
d->dc.samples = 0;
} else {
qDebug() << "changing the duration on a dive that wasn't manually added - Uh-oh";
}
}
if (get_depth_string(d->maxdepth.mm, true, true) != depth) {
int depthValue = parseLengthToMm(depth);
// the QML code should stop negative depth, but massively huge depth can make
// the profile extremely slow or even run out of memory and crash, so keep
// the depth <= 500m
if (0 <= depthValue && depthValue <= 500000) {
diveChanged = true;
d->maxdepth.mm = depthValue;
if (same_string(d->dc.model, "manually added dive")) {
d->dc.maxdepth.mm = d->maxdepth.mm;
free(d->dc.sample);
d->dc.sample = 0;
d->dc.samples = 0;
}
}
}
if (get_temperature_string(d->airtemp, true) != airtemp) {
diveChanged = true;
d->airtemp.mkelvin = parseTemperatureToMkelvin(airtemp);
}
if (get_temperature_string(d->watertemp, true) != watertemp) {
diveChanged = true;
d->watertemp.mkelvin = parseTemperatureToMkelvin(watertemp);
}
// not sure what we'd do if there was more than one weight system
// defined - for now just ignore that case
if (weightsystem_none((void *)&d->weightsystem[1])) {
if (get_weight_string(d->weightsystem[0].weight, true) != weight) {
diveChanged = true;
d->weightsystem[0].weight.grams = parseWeightToGrams(weight);
}
}
// start and end pressures for first cylinder only
if (get_pressure_string(d->cylinder[0].start, true) != startpressure || get_pressure_string(d->cylinder[0].end, true) != endpressure) {
diveChanged = true;
d->cylinder[0].start.mbar = parsePressureToMbar(startpressure);
d->cylinder[0].end.mbar = parsePressureToMbar(endpressure);
if (d->cylinder[0].end.mbar > d->cylinder[0].start.mbar)
d->cylinder[0].end.mbar = d->cylinder[0].start.mbar;
}
// gasmix for first cylinder
if (get_gas_string(d->cylinder[0].gasmix) != gasmix) {
int o2 = parseGasMixO2(gasmix);
int he = parseGasMixHE(gasmix);
// the QML code SHOULD only accept valid gas mixes, but just to make sure
if (o2 >= 0 && o2 <= 1000 &&
he >= 0 && he <= 1000 &&
o2 + he <= 1000) {
diveChanged = true;
d->cylinder[0].gasmix.o2.permille = o2;
d->cylinder[0].gasmix.he.permille = he;
}
}
if (!same_string(d->suit, qPrintable(suit))) {
diveChanged = true;
free(d->suit);
d->suit = strdup(qPrintable(suit));
}
if (!same_string(d->buddy, qPrintable(buddy))) {
diveChanged = true;
free(d->buddy);
d->buddy = strdup(qPrintable(buddy));
}
if (!same_string(d->divemaster, qPrintable(diveMaster))) {
diveChanged = true;
free(d->divemaster);
d->divemaster = strdup(qPrintable(diveMaster));
}
if (!same_string(d->notes, qPrintable(notes))) {
diveChanged = true;
free(d->notes);
d->notes = strdup(qPrintable(notes));
}
// now that we have it all figured out, let's see what we need
// to update
DiveListModel *dm = DiveListModel::instance();
int oldModelIdx = dm->getDiveIdx(d->id);
int oldIdx = get_idx_by_uniq_id(d->id);
if (needResort) {
// we know that the only thing that might happen in a resort is that
// this one dive moves to a different spot in the dive list
sort_table(&dive_table);
int newIdx = get_idx_by_uniq_id(d->id);
if (newIdx != oldIdx) {
DiveObjectHelper *newDive = new DiveObjectHelper(d);
DiveListModel::instance()->removeDive(oldModelIdx);
DiveListModel::instance()->insertDive(oldModelIdx - (newIdx - oldIdx), newDive);
diveChanged = false; // because we already modified things
}
}
if (diveChanged) {
if (d->maxdepth.mm == d->dc.maxdepth.mm &&
d->maxdepth.mm > 0 &&
same_string(d->dc.model, "manually added dive") &&
d->dc.samples == 0) {
// so we have depth > 0, a manually added dive and no samples
// let's create an actual profile so the desktop version can work it
// first clear out the mean depth (or the fake_dc() function tries
// to be too clever
d->meandepth.mm = d->dc.meandepth.mm = 0;
d->dc = *fake_dc(&d->dc, true);
}
DiveListModel::instance()->updateDive(oldModelIdx, d);
}
if (diveChanged || needResort)
// we no longer save right away, but only the next time the app is not
// in the foreground (or when explicitly requested)
mark_divelist_changed(true);
}
AbstractMotor::motorState AbstractMotor::getState() {
motorState state;
state["target"] = getPosition();
state["current"] = getCurrentPosition();
return state;
};
double Dxl::getCurrentAngleRadian(unsigned int device_id) const
{
return getCurrentPosition(device_id) * POSITION_TO_RADIAN;
}
double Dxl::getCurrentAngleDegree(unsigned int device_id) const
{
return getCurrentPosition(device_id) * POSITION_TO_DEGREE;
}
void ofxAnimatableOfPoint::animateTo( ofPoint where ){
originalPoint_ = getCurrentPosition();
targetPoint_ = where;
ofxAnimatable::startAnimation();
}
XnFloat User::getCurrentDistance()
{
XnVector3D position = getCurrentPosition();
return sqrt((position.Z*position.Z)+(position.X*position.X));
}