自学教程：C++ update_position函数代码示例

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 voidrun(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 voidSafeMoveWindow(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 voidSafeMoveWindow(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(&current);	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);	}}

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();}