Array<TV> SurfacePins::closest_points(Array<const TV> X) {
update_position(X,false);
Array<TV> closest(particles.size(),uninit);
for (int i=0;i<particles.size();i++)
closest[i] = X[particles[i]]-info[i].phi*info[i].normal;
return closest;
}
static void
run(LV2_Handle instance, uint32_t sample_count)
{
Metro* self = (Metro*)instance;
const MetroURIs* uris = &self->uris;
// Work forwards in time frame by frame, handling events as we go
const LV2_Atom_Sequence* in = self->ports.control;
uint32_t last_t = 0;
for (const LV2_Atom_Event* ev = lv2_atom_sequence_begin(&in->body);
!lv2_atom_sequence_is_end(&in->body, in->atom.size, ev);
ev = lv2_atom_sequence_next(ev)) {
// Play the click for the time slice from last_t until now
play(self, last_t, ev->time.frames);
// Check if this event is an Object
// (or deprecated Blank to tolerate old hosts)
if (ev->body.type == uris->atom_Object ||
ev->body.type == uris->atom_Blank) {
const LV2_Atom_Object* obj = (const LV2_Atom_Object*)&ev->body;
if (obj->body.otype == uris->time_Position) {
// Received position information, update
update_position(self, obj);
}
}
// Update time for next iteration and move to next event
last_t = ev->time.frames;
}
// Play for remainder of cycle
play(self, last_t, sample_count);
}
DLL_EXPORT void
SafeMoveWindow(unsigned int serial, HWND hwnd, int x, int y, int width, int height)
{
RECT rect;
if (IsZoomed(hwnd))
return;
WaitForSingleObject(g_mutex, INFINITE);
g_block_move_hwnd = hwnd;
g_block_move_serial = serial;
g_block_move.left = x;
g_block_move.top = y;
g_block_move.right = x + width;
g_block_move.bottom = y + height;
ReleaseMutex(g_mutex);
SetWindowPos(hwnd, NULL, x, y, width, height, SWP_NOACTIVATE | SWP_NOZORDER);
vchannel_write("ACK", "%u", serial);
if (!GetWindowRect(hwnd, &rect))
debug("GetWindowRect failed!\n");
else if ((rect.left != x) || (rect.top != y) || (rect.right != x + width)
|| (rect.bottom != y + height))
update_position(hwnd);
else if (! IsIconic(hwnd))
vchannel_write("POSITION", "0x%08lx,%d,%d,%d,%d,0x%08x", hwnd, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, 0);
WaitForSingleObject(g_mutex, INFINITE);
g_block_move_hwnd = NULL;
memset(&g_block_move, 0, sizeof(RECT));
ReleaseMutex(g_mutex);
}
static void handle_resize(struct view_handler * handler,
uint32_t old_width, uint32_t old_height)
{
struct panel * panel = wl_container_of(handler, panel, view_handler);
update_position(panel);
}
/************************************************************
Main Loop
************************************************************/
int main(void)
{
/* Confirm Power */
m_red(ON);
/* Initializations */
initialize_robockey();
pause();
play();
/* Confirm successful initialization(s) */
m_green(ON);
/* Run */
while (1){
update_position();
if (check(ADCSRA,ADIF)){adc_update();} // Check if ADC conversion has completed
bot_behavior_update();
if (check(TIFR3,OCF3A)){motor_update();} // Check if timestep has completed
if (wifi_flag) {
wifi_flag = 0;
m_red(TOGGLE);
wireless_recieve();
}
}
}
void utf8iterator_next(Utf8Iterator* iter) {
// We update positions based on the *last* character read, so that the first
// character following a newline is at column 1 in the next line.
update_position(iter);
iter->_start += iter->_width;
read_char(iter);
}
static gboolean update_position_idle(NotifyStack* stack)
{
update_position(stack);
stack->update_id = 0;
return FALSE;
}
void CPs2NewParticle::plat_update( void )
{
if (m_params.m_LocalCoord)
{
update_position();
}
}
int
SKY_BOX::DrawGradient(CVIEWptr &v)
{
//DebugBreak();
update_position(); //center at the eye position
Patch* p = get_patch();
assert(p);
Skybox_Texture* tex = get_tex<Skybox_Texture>(p);
assert(tex);
glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT );
glEnable(GL_DEPTH_TEST);
// set xform:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glMultMatrixd(xform().transpose().matrix());
// draw the mesh normally:
int ret= tex->draw(v);
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glPopAttrib();
GL_VIEW_PRINT_GL_ERRORS("(regular) : ");
return ret;
}
void VWindow::change_source(EDL *edl)
{
//printf("VWindow::change_source(EDL *edl) 1\n");
//printf("VWindow::change_source %p\n", edl);
// EDLs are identical
if(edl && mwindow->edl->vwindow_edl &&
edl->id == mwindow->edl->vwindow_edl->id) return;
delete_edl();
if(edl)
{
this->asset = 0;
mwindow->edl->vwindow_edl = edl;
// in order not to later delete edl if it is shared
mwindow->edl->vwindow_edl_shared = 1;
// Update GUI
gui->change_source(edl, edl->local_session->clip_title);
update_position(CHANGE_ALL, 1, 1);
// Update master session
strcpy(mwindow->edl->session->vwindow_folder, CLIP_FOLDER);
mwindow->edl->session->vwindow_source =
mwindow->edl->clips.number_of(edl);
}
else
gui->change_source(edl, _("Viewer"));
}
/*
* Move robot forward, update current position and perform adjustments if the cell has been visited before
*/
void move()
{
move_forward();
update_position();
int i = find_current_cell();
int k = find_prev_cell();
if (cells[i].visited == 0) {
check_walls();
determ_type(i);
checked_walls = 1;
drive_through = 0;
}
else {
checked_walls = 1;
check_wall_weights();
printf("Attempting adjustment...\n");
drive_through = 1;
perform_angle_adjustment(k, i);
perform_one_wall_adjustment(i);
}
update_visited();
}
EXTERN void
SafeMoveWindow(unsigned int serial, HWND hwnd, int x, int y, int width,
int height)
{
RECT rect;
if (!g_wm_seamless_focus)
return;
WaitForSingleObject(g_mutex, INFINITE);
g_shdata->block_move_hwnd = hwnd_to_long(hwnd);
g_shdata->block_move_serial = serial;
g_shdata->block_move.left = x;
g_shdata->block_move.top = y;
g_shdata->block_move.right = x + width;
g_shdata->block_move.bottom = y + height;
ReleaseMutex(g_mutex);
SetWindowPos(hwnd, NULL, x, y, width, height,
SWP_NOACTIVATE | SWP_NOZORDER);
vchannel_write("ACK", "%u", serial);
if (!GetWindowRect(hwnd, &rect))
debug("GetWindowRect failed!");
else if ((rect.left != x) || (rect.top != y) || (rect.right != x + width)
|| (rect.bottom != y + height))
update_position(hwnd);
WaitForSingleObject(g_mutex, INFINITE);
g_shdata->block_move_hwnd = 0;
memset(&g_shdata->block_move, 0, sizeof(RECT));
ReleaseMutex(g_mutex);
}
void ocl_one_step_move(sotl_device_t *dev)
{
if (gravity_enabled)
gravity (dev);
#ifdef _SPHERE_MODE_
if (eating_enabled)
eating_pacman (dev);
if (growing_enabled)
growing_ghost (dev);
#endif
if (force_enabled)
// Classic n^2 compute force version
n2_lennard_jones (dev);
if(detect_collision)
atom_collision (dev);
if(borders_enabled)
border_collision (dev);
update_position (dev);
#ifdef HAVE_LIBGL
if (dev->display)
update_vertices (dev);
#endif
}
void SoundPlayer::init(float volume, float x, float y, float z) {
stop = true;
paused = true;
pthread_mutex_init(&player_mutex, NULL);
pthread_mutex_init(&control_mutex, NULL);
update_volume(volume);
update_position(x, y, z);
}
bool handle_event(mouse_position npos){
int dx = npos.x - 200;
int dy = npos.y - 200;
SetMousePosition(200,200);
r1 += dx;
r2 += dy;
update_position(0,0,dx,dy);
return true;
}
//struct sphere move_on_curve( struct sphere *ball ) {
void move_on_curve( struct sphere *ball ) {
point3f temp;
temp = ball->pos;
// store previous position
ball->previous_pos = temp;
ball->interval =( current - ball->start_time )/
( CLOCKS_PER_SEC * ball->curve_time );
update_position( ball );
}
/*
* advances the sphere along the curved path
*/
void Sphere::move_on_curve(double current) {
point3f temp;
temp = pos;
// store previous position
previous_pos = temp;
interval =( current - start_time )/
( CLOCKS_PER_SEC * curve_time );
update_position();
}
/*
update the Gazebo simulation by one time step
*/
void Gazebo::update(const struct sitl_input &input)
{
send_servos(input);
recv_fdm(input);
update_position();
// update magnetic field
update_mag_field_bf();
}
int play_game(){
draw_border();
update_position();
draw_snake();
usleep(get_speed());
return 1;
}
int pSim::Update()
{
#ifdef VERBOSE
update_log << "Update no contact" << endl;
#endif
#ifdef TIMING_CHECK
update_start_time = MPI_Wtime();
#endif
#ifdef PSIM_TEST
max_condition_number = -1.0;
max_sigma_ratio = -1.0;
max_condition_number_joint = 0;
max_sigma_ratio_joint = 0;
condition_numbers.resize(n_dof);
sigma_ratios.resize(n_dof);
condition_numbers.zero();
sigma_ratios.zero();
total_gamma_error = 0.0;
#endif
/**** assembly ****/
// position-dependent variables
update_position();
#if 1
if(do_connect)
{
//
// do collision computation if needed
//
update_collision();
// don't forget to recompute link velocities
CalcVelocity();
do_connect = false;
}
#endif
// velocity-dependent variables
update_velocity();
#ifdef TIMING_CHECK
cerr << "[" << rank << "] disassembly t = " << MPI_Wtime()-update_start_time << endl;
#endif
/**** disassembly ****/
disassembly();
#ifdef PSIM_TEST
cerr << "--- max condition number = " << max_condition_number << " at " << max_condition_number_joint->name << endl;
cerr << "--- max sigma ratio = " << max_sigma_ratio << " at " << max_sigma_ratio_joint->name << endl;
cerr << "--- total_gamma_error = " << total_gamma_error << endl;
// cerr << "condition_numbers = " << tran(condition_numbers) << endl;
// cerr << "sigma_ratios = " << tran(sigma_ratios) << endl;
#endif
#ifdef USE_MPI
// scatter results
scatter_acc();
#endif
return 0;
}
static void set_offset(struct wl_client * client, struct wl_resource * resource,
uint32_t offset)
{
struct panel * panel = wl_resource_get_user_data(resource);
panel->offset = offset;
if (panel->docked)
update_position(panel);
}
int write_data(databuf_t* db, int pos) {
update_position(&track);
pos = race_write_short(db,pos,TRACK_MSG);
pos = race_write_short(db,pos,1); // we only send one track (for now)
pos = race_write_track_data(db, pos,
track.id, track.time_msec, track.lat_deg, track.lon_deg,
track.alt_m, track.heading_deg, track.speed_m_sec);
return pos;
}
/*
update the last_letter simulation by one time step
*/
void last_letter::update(const struct sitl_input &input)
{
send_servos(input);
recv_fdm(input);
sync_frame_time();
update_position();
// update magnetic field
update_mag_field_bf();
}
void collision_avoided(double direction, struct timeval time){
running = 0;
current.timer = time;
free(route.path);
compare_tile();
current.current_destination.angle = direction;
update_position(¤t);
compare_tile();
recalc();
}
void VWindow::goto_start()
{
if(get_edl())
{
get_edl()->local_session->set_selectionstart(0);
get_edl()->local_session->set_selectionend(0);
update_position(CHANGE_NONE,
0,
1);
}
}
int
SKY_BOX::draw_color_ref(int i)
{
if (i != 0)
return 0;
update_position();
// XXX - probably wrong...
return DrawGradient(VIEW::peek());
}
void reduction_entropy::
update_surfel_attributes(shared_surfel target_surfel_ptr,
shared_entropy_surfel_vector const invalidated_neighbours) const {
update_normal(target_surfel_ptr, invalidated_neighbours);
update_color(target_surfel_ptr, invalidated_neighbours);
// position needs to be updated before the radius is updated
update_position(target_surfel_ptr, invalidated_neighbours);
update_radius(target_surfel_ptr, invalidated_neighbours);
}
void utf8iterator_next(Utf8Iterator* iter) {
iter->_start += iter->_width;
// We update positions based on the *last* character read, so that the first
// character following a newline is at column 1 in the next line.
update_position(iter);
if (iter->_start < iter->_end) {
read_char(iter);
} else { // EOF
iter->_current = -1;
}
}
//struct sphere move_on_curve( struct sphere *ball ) {
void move_on_curve( struct sphere *ball ) {
struct point2f temp;
temp = ball->pos;
// store previous position
ball->previous_pos = temp;
ball->interval =( current - ball->start_time )/
( CLOCKS_PER_SEC * ball->curve_time );
//printf("before update: %f %f || %f %f\n", ball->previous_pos.x, ball->previous_pos.y, ball->pos.x, ball->pos.y);
update_position( ball );
//printf("after update: %f %f || %f %f\n", ball->previous_pos.x, ball->previous_pos.y, ball->pos.x, ball->pos.y);
}
void CombatGameInst::attempt_move_to_position(GameState* gs, float& newx,
float& newy) {
float dx = newx - rx, dy = newy - ry;
float dist = sqrt(dx * dx + dy * dy);
bool collided = gs->tile_radius_test(round(newx), round(newy), 20);
if (!collided) {
rx = newx, ry = newy;
} else {
float nx = round(rx + vx), ny = round(ry + vy);
bool collided = gs->tile_radius_test(nx, ny, radius);
if (collided) {
bool hitsx = gs->tile_radius_test(nx, y, radius);
bool hitsy = gs->tile_radius_test(x, ny, radius);
if (hitsy || hitsx || collided) {
if (hitsx) {
vx = 0;
}
if (hitsy) {
vy = 0;
}
if (!hitsy && !hitsx) {
vx = -vx;
vy = -vy;
}
}
}
// else {
// if (in_corridor_heurestic(gs,
// Pos(rx / TILE_SIZE, ry / TILE_SIZE))) {
// float proportion = proportion_in_same_dir(dx, dy, vx, vy);
// if (!gs->tile_radius_test(round(rx + vx * proportion),
// round(ry + vy * proportion), radius)) {
// vx *= proportion, vy *= proportion;
// } else {
// vx = 0.0f, vy = 0.0f;
// }
// }
// }
// normalize(nx, ny, effective_stats().movespeed);
vx = round(vx * ROUNDING_MULTIPLE) / ROUNDING_MULTIPLE;
vy = round(vy * ROUNDING_MULTIPLE) / ROUNDING_MULTIPLE;
rx += vx;
ry += vy;
}
newx = rx, newy = ry;
update_position();
}
