LRESULT CVariablePage::OnInitDialog(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) { ATLASSERT(m_piCurrentClass); START_PROFILE(VarInit); CreateControls(); m_DDXManager.SetGlobalParams(m_hWnd, m_pModifications, m_pResManager); CRect r; m_Variables.GetClientRect(r); m_Variables.InsertColumn(0, _T("ID"), LVCFMT_LEFT, m_WindowSettings.m_VariableWidth, 0); m_Variables.InsertColumn(1, _T("Variable"), LVCFMT_LEFT, r.Width() - m_WindowSettings.m_VariableWidth - 5, 1); m_Variables.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT); START_PROFILE(VarDlg); for (size_t i = 0; i < m_pClassVector->GetCount(); i++) { VSClass* pCurClass = (*m_pClassVector)[i]; if (!m_bOnlyDlgs || (pCurClass->IsDialog() && !(pCurClass->m_DialogID.IsEmpty()))) { int iItem = m_Classes.AddString(pCurClass->Name); m_Classes.SetItemData(iItem, i); } } END_PROFILE(VarDlg, _T("CVariablePage::OnInitDialog check dialog classes")); m_Classes.SetCurSel(0); m_ToolbarImgList.CreateFromImage(IDB_BITMAP_DDX, 18, 1, RGB(197, 200,201), IMAGE_BITMAP, LR_CREATEDIBSECTION); InitToolTip(); END_PROFILE(VarInit, _T("CVariablePage::OnInitDialog")); return 0; }
static void ReOneStep(double deltaTimeIncrement) { int i; tRobotItf *robot; tSituation *s = ReInfo->s; if (floor(s->currentTime) == -2.0) { ReRaceBigMsgSet("Ready", 1.0); } else if (floor(s->currentTime) == -1.0) { ReRaceBigMsgSet("Set", 1.0); } else if (floor(s->currentTime) == 0.0) { ReRaceBigMsgSet("Go", 1.0); } ReInfo->_reCurTime += deltaTimeIncrement * ReInfo->_reTimeMult; /* "Real" time */ s->currentTime += deltaTimeIncrement; /* Simulated time */ if (s->currentTime < 0) { /* no simu yet */ ReInfo->s->_raceState = RM_RACE_PRESTART; } else if (ReInfo->s->_raceState == RM_RACE_PRESTART) { ReInfo->s->_raceState = RM_RACE_RUNNING; s->currentTime = 0.0; /* resynchronize */ ReInfo->_reLastTime = 0.0; } START_PROFILE("rbDrive*"); if ((s->currentTime - ReInfo->_reLastTime) >= RCM_MAX_DT_ROBOTS) { s->deltaTime = s->currentTime - ReInfo->_reLastTime; for (i = 0; i < s->_ncars; i++) { if ((s->cars[i]->_state & RM_CAR_STATE_NO_SIMU) == 0) { robot = s->cars[i]->robot; robot->rbDrive(robot->index, s->cars[i], s); } } ReInfo->_reLastTime = s->currentTime; } STOP_PROFILE("rbDrive*"); START_PROFILE("_reSimItf.update*"); ReInfo->_reSimItf.update(s, deltaTimeIncrement, -1); for (i = 0; i < s->_ncars; i++) { ReManage(s->cars[i]); } STOP_PROFILE("_reSimItf.update*"); ReRaceMsgUpdate(); ReSortCars(); }
int ReUpdate(void) { double t; tRmMovieCapture *capture; START_PROFILE("ReUpdate"); ReInfo->_refreshDisplay = 0; switch (ReInfo->_displayMode) { case RM_DISP_MODE_NORMAL: t = GfTimeClock(); START_PROFILE("ReOneStep*"); while (ReInfo->_reRunning && ((t - ReInfo->_reCurTime) > RCM_MAX_DT_SIMU)) { ReOneStep(RCM_MAX_DT_SIMU); } STOP_PROFILE("ReOneStep*"); GfuiDisplay(); ReInfo->_reGraphicItf.refresh(ReInfo->s); glutPostRedisplay(); /* Callback -> reDisplay */ break; case RM_DISP_MODE_NONE: ReOneStep(RCM_MAX_DT_SIMU); if (ReInfo->_refreshDisplay) { GfuiDisplay(); } glutPostRedisplay(); /* Callback -> reDisplay */ break; case RM_DISP_MODE_CAPTURE: capture = &(ReInfo->movieCapture); while ((ReInfo->_reCurTime - capture->lastFrame) < capture->deltaFrame) { ReOneStep(capture->deltaSimu); } capture->lastFrame = ReInfo->_reCurTime; GfuiDisplay(); ReInfo->_reGraphicItf.refresh(ReInfo->s); reCapture(); glutPostRedisplay(); /* Callback -> reDisplay */ break; } STOP_PROFILE("ReUpdate"); return RM_ASYNC; }
bool CSpaceRestrictionBridge::on_border (const Fvector &position) const { START_PROFILE("Restricted Object/Bridge/On Border"); VERIFY (ai().level_graph().valid_vertex_position(position)); CLevelGraph::CPosition pos = ai().level_graph().vertex_position(position); xr_vector<u32>::const_iterator E = object().border().end(); xr_vector<u32>::const_iterator I = std::lower_bound ( object().border().begin(), object().border().end(), pos.xz(), CFindByXZ_predicate() ); if ((I == E) || (ai().level_graph().vertex(*I)->position().xz() != pos.xz())) return (false); for (I ; I != E; ++I) { if (ai().level_graph().vertex(*I)->position().xz() != pos.xz()) break; if (_abs(ai().level_graph().vertex_plane_y(*I) - position.y) < 2.f) return (true); } return (false); STOP_PROFILE; }
bool CRestrictedObject::accessible (u32 level_vertex_id, float radius) const { START_PROFILE("Restricted Object/Accessible"); VERIFY (ai().level_graph().valid_vertex_id(level_vertex_id)); return (Level().space_restriction_manager().accessible(object().ID(),level_vertex_id,radius)); STOP_PROFILE; }
bool CRestrictedObject::accessible (u32 level_vertex_id) const { START_PROFILE("Restricted Object/Accessible"); VERIFY (ai().level_graph().valid_vertex_id(level_vertex_id)); return (accessible(level_vertex_id,EPS_L)); STOP_PROFILE; }
static int vfswrap_ntimes(vfs_handle_struct *handle, const char *path, const struct timespec ts[2]) { int result; START_PROFILE(syscall_ntimes); #if defined(HAVE_UTIMES) { struct timeval tv[2]; tv[0] = convert_timespec_to_timeval(ts[0]); tv[1] = convert_timespec_to_timeval(ts[1]); result = utimes(path, tv); } #elif defined(HAVE_UTIME) { struct utimbuf times; times.actime = convert_timespec_to_time_t(ts[0]); times.modtime = convert_timespec_to_time_t(ts[1]); result = utime(path, times); } #else errno = ENOSYS; result = -1; #endif END_PROFILE(syscall_ntimes); return result; }
void CSpaceRestriction::merge_free_in_retrictions () { START_PROFILE("Restricted Object/Merge Free In"); string256 temp; for (u32 i=0, n=_GetItemCount(*m_in_restrictions); i<n ;++i) { SpaceRestrictionHolder::CBaseRestrictionPtr bridge = m_space_restriction_manager->restriction(shared_str(_GetItem(*m_in_restrictions,i,temp))); m_free_in_restrictions.push_back (CFreeInRestriction(bridge,false)); } RESTRICTIONS temp_restrictions; for (bool ok = false; !ok; ) { ok = true; temp_restrictions.clear (); FREE_IN_RESTRICTIONS::iterator I = m_free_in_restrictions.begin(), J; FREE_IN_RESTRICTIONS::iterator E = m_free_in_restrictions.end(); for ( ; I != E; ++I) { for (J = I + 1; J != E; ++J) if (intersects((*I).m_restriction,(*J).m_restriction)) temp_restrictions.push_back ((*J).m_restriction); if (!temp_restrictions.empty()) { J = remove_if(m_free_in_restrictions.begin(),m_free_in_restrictions.end(),CRemoveMergedFreeInRestrictions(temp_restrictions)); m_free_in_restrictions.erase (J,m_free_in_restrictions.end()); (*I).m_restriction = merge((*I).m_restriction,temp_restrictions); ok = false; break; } } } STOP_PROFILE; }
static uint64_t onefs_get_alloc_size(struct vfs_handle_struct *handle, files_struct *fsp, const SMB_STRUCT_STAT *sbuf) { uint64_t result; START_PROFILE(syscall_get_alloc_size); if(S_ISDIR(sbuf->st_mode)) { result = 0; goto out; } /* Just use the file size since st_blocks is unreliable on OneFS. */ result = get_file_size_stat(sbuf); if (fsp && fsp->initial_allocation_size) result = MAX(result,fsp->initial_allocation_size); result = smb_roundup(handle->conn, result); out: END_PROFILE(syscall_get_alloc_size); return result; }
/**************************************************************************** reply to a sendtxt ****************************************************************************/ int reply_sendtxt(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { int len; int outsize = 0; char *msg; START_PROFILE(SMBsendtxt); if (! (*lp_msg_command())) { END_PROFILE(SMBsendtxt); return(ERROR_DOS(ERRSRV,ERRmsgoff)); } outsize = set_message(outbuf,0,0,True); msg = smb_buf(inbuf) + 1; len = SVAL(msg,0); len = MIN(len,sizeof(msgbuf)-msgpos); memcpy(&msgbuf[msgpos],msg+2,len); msgpos += len; DEBUG( 3, ( "SMBsendtxt\n" ) ); END_PROFILE(SMBsendtxt); return(outsize); }
/**************************************************************************** reply to a sendstrt ****************************************************************************/ int reply_sendstrt(connection_struct *conn, char *inbuf,char *outbuf, int dum_size, int dum_buffsize) { int outsize = 0; char *p; START_PROFILE(SMBsendstrt); if (! (*lp_msg_command())) { END_PROFILE(SMBsendstrt); return(ERROR_DOS(ERRSRV,ERRmsgoff)); } outsize = set_message(outbuf,1,0,True); memset(msgbuf,'\0',sizeof(msgbuf)); msgpos = 0; p = smb_buf(inbuf)+1; p += srvstr_pull_buf(inbuf, msgfrom, p, sizeof(msgfrom), STR_TERMINATE) + 1; p += srvstr_pull_buf(inbuf, msgto, p, sizeof(msgto), STR_TERMINATE) + 1; DEBUG( 3, ( "SMBsendstrt (from %s to %s)\n", msgfrom, msgto ) ); END_PROFILE(SMBsendstrt); return(outsize); }
void SoundSystem::TriggerEvent( char *_type, char *_eventName, Vector3<float> const &_pos ) { if( !m_channels ) return; START_PROFILE("TriggerEvent"); SoundEventBlueprint *seb = m_blueprints.GetBlueprint(_type); if( seb ) { for( int i = 0; i < seb->m_events.Size(); ++i ) { SoundInstanceBlueprint *sib = seb->m_events[i]; if( stricmp( sib->m_eventName, _eventName ) == 0 ) { SoundInstance *instance = new SoundInstance(); instance->Copy( sib->m_instance ); instance->m_pos = _pos; bool success = InitialiseSound ( instance ); if( !success ) ShutdownSound ( instance ); } } } END_PROFILE("TriggerEvent"); }
void Tripod::AdvancePreAttack() { START_PROFILE(g_app->m_profiler, "AdvancePreAttack"); // Exit if we haven't come to a stop yet if (m_vel.Mag() > 0.05f) { END_PROFILE(g_app->m_profiler, "AdvancePreAttack"); return; } m_targetHoverHeight = ATTACK_HOVER_HEIGHT; // See if we have achieved a full crouch yet float height = m_pos.y - g_app->m_location->m_landscape.m_heightMap->GetValue(m_pos.x, m_pos.z); if (height < ATTACK_HOVER_HEIGHT + 0.5f) { m_mode = ModeAttacking; m_modeStartTime = g_gameTime; } // Blend into attack orientation Vector3 desiredUp = CalcAttackUpVector(); float factor1 = 0.8f * SERVER_ADVANCE_PERIOD; float factor2 = 1.0f - factor1; m_up = factor1 * desiredUp + factor2 * m_up; Vector3 right = m_up ^ m_front; m_front = right ^ m_up; m_front.Normalise(); END_PROFILE(g_app->m_profiler, "AdvancePreAttack"); }
void CMovementManager::move_along_path (CPHMovementControl *movement_control, Fvector &dest_position, float time_delta) { START_PROFILE("Build Path/Move Along Path") VERIFY(movement_control); Fvector motion; dest_position = object().Position(); float precision = 0.5f; // Если нет движения по пути if ( !enabled() || !actual() || // path_completed() || detail().path().empty() || detail().completed(dest_position,true) || (detail().curr_travel_point_index() >= detail().path().size() - 1) || fis_zero(old_desirable_speed()) ) { m_speed = 0.f; DBG_PH_MOVE_CONDITIONS( if(ph_dbg_draw_mask.test(phDbgNeverUseAiPhMove)){movement_control->SetPosition(dest_position);movement_control->DisableCharacter();}) if(movement_control->IsCharacterEnabled()) {
Vector2 Tripod::ChooseDestination() { START_PROFILE(g_app->m_profiler, "ChooseDest"); int numFound; WorldObjectId *enemies = g_app->m_location->m_entityGrid->GetEnemies(m_pos.x, m_pos.z, NAVIGATION_SEARCH_RADIUS, &numFound, m_id.GetTeamId()); Vector2 pos; if (numFound == 0) { pos = m_pos; pos.x += syncsfrand(300.0f); pos.y += syncsfrand(300.0f); } else { int i = syncrand() % numFound; Entity *targetEnemy = g_app->m_location->GetEntity(enemies[i]); pos = targetEnemy->m_pos; pos.x += syncsfrand(100.0f); pos.y += syncsfrand(100.0f); } END_PROFILE(g_app->m_profiler, "ChooseDest"); return pos; }
void CHitMemoryManager::update() { START_PROFILE("Memory Manager/hits::update") clear_delayed_objects (); VERIFY (m_hits); m_hits->erase ( std::remove_if( m_hits->begin(), m_hits->end(), CRemoveOfflinePredicate() ), m_hits->end() ); #ifdef USE_SELECTED_HIT xr_delete (m_selected_hit); u32 level_time = 0; HITS::const_iterator I = m_hits->begin(); HITS::const_iterator E = m_hits->end(); for ( ; I != E; ++I) { if ((*I).m_level_time > level_time) { xr_delete (m_selected_hit); m_selected_hit = new CHitObject(*I); level_time = (*I).m_level_time; } } #endif STOP_PROFILE }
WorldObjectId Tripod::FindEntityToAttack() { START_PROFILE(g_app->m_profiler, "FindEntityToA"); WorldObjectId id; int numFound; WorldObjectId *enemies = g_app->m_location->m_entityGrid->GetEnemies(m_pos.x, m_pos.z, ATTACK_SEARCH_RADIUS, &numFound, m_id.GetTeamId()); int nearest = -1; float nearestDistSqrd = FLT_MAX; for (int i = 0; i < numFound; ++i) { Entity *entity = g_app->m_location->GetEntity(enemies[i]); float deltaX = entity->m_pos.x - m_pos.x; float deltaY = entity->m_pos.z - m_pos.z; float distSqrd = deltaX * deltaX + deltaY * deltaY; if (distSqrd < nearestDistSqrd) { nearestDistSqrd = distSqrd; nearest = i; } } if (nearest != -1) { id = enemies[nearest]; } END_PROFILE(g_app->m_profiler, "FindEntityToA"); return id; }
//BUG #606/#VV4 Neighbors/affinities: This call returns affinities with identical mapping across PDs. u8 ocrAffinityGet(ocrAffinityKind kind, u64 * count, ocrGuid_t * affinities) { START_PROFILE(api_ocrAffinityGet); ocrPolicyDomain_t * pd = NULL; getCurrentEnv(&pd, NULL, NULL, NULL); ocrPlatformModelAffinity_t * platformModel = ((ocrPlatformModelAffinity_t*)pd->platformModel); if(platformModel == NULL) { ASSERT(*count > 0); *count = 1; affinities[0] = NULL_GUID; RETURN_PROFILE(0); } if (kind == AFFINITY_PD) { ASSERT(*count <= (pd->neighborCount + 1)); u64 i = 0; while(i < *count) { affinities[i] = platformModel->pdLocAffinities[i]; i++; } } else if (kind == AFFINITY_PD_MASTER) { //BUG #610 Master PD: This should likely come from the INI file affinities[0] = platformModel->pdLocAffinities[0]; } else if (kind == AFFINITY_CURRENT) { affinities[0] = platformModel->pdLocAffinities[platformModel->current]; } else { ASSERT(false && "Unknown affinity kind"); } RETURN_PROFILE(0); }
void CSoundMemoryManager::update() { START_PROFILE("Memory Manager/sounds::update") clear_delayed_objects (); VERIFY (m_sounds); m_sounds->erase ( std::remove_if( m_sounds->begin(), m_sounds->end(), CRemoveOfflinePredicate() ), m_sounds->end() ); #ifdef USE_SELECTED_SOUND xr_delete (m_selected_sound); u32 priority = u32(-1); xr_vector<CSoundObject>::const_iterator I = m_sounds->begin(); xr_vector<CSoundObject>::const_iterator E = m_sounds->end(); for ( ; I != E; ++I) { u32 cur_priority = this->priority(*I); if (cur_priority < priority) { m_selected_sound = xr_new<CSoundObject>(*I); priority = cur_priority; } } #endif STOP_PROFILE }
u8 ocrAffinityGetAt(ocrAffinityKind kind, u64 idx, ocrGuid_t * affinity) { START_PROFILE(api_ocrAffinityGetAt); ocrPolicyDomain_t * pd = NULL; getCurrentEnv(&pd, NULL, NULL, NULL); ocrPlatformModelAffinity_t * platformModel = ((ocrPlatformModelAffinity_t*)pd->platformModel); if(platformModel == NULL) { ASSERT(idx > 0); affinity[0] = NULL_GUID; RETURN_PROFILE(OCR_EINVAL); } if (kind == AFFINITY_PD) { if (idx > (pd->neighborCount + 1)) { ASSERT(false && "error: ocrAffinityGetAt index is out of bounds"); RETURN_PROFILE(OCR_EINVAL); } affinity[0] = platformModel->pdLocAffinities[idx]; } else if (kind == AFFINITY_PD_MASTER) { //BUG #610 Master PD: This should likely come from the INI file affinity[0] = platformModel->pdLocAffinities[0]; } else if (kind == AFFINITY_CURRENT) { affinity[0] = platformModel->pdLocAffinities[platformModel->current]; } else { ASSERT(false && "Unknown affinity kind"); } RETURN_PROFILE(0); }
u8 ocrAffinityQuery(ocrGuid_t guid, u64 * count, ocrGuid_t * affinities) { START_PROFILE(api_ocrAffinityQuery); ocrPolicyDomain_t * pd = NULL; getCurrentEnv(&pd, NULL, NULL, NULL); ocrPlatformModelAffinity_t * platformModel = ((ocrPlatformModelAffinity_t*)pd->platformModel); if(platformModel == NULL) { if (count != NULL) { ASSERT(*count > 0); *count = 1; } affinities[0] = NULL_GUID; RETURN_PROFILE(0); } else { if (count != NULL) { ASSERT(*count > 0); *count = 1; } if (ocrGuidIsNull(guid)) { affinities[0] = platformModel->pdLocAffinities[platformModel->current]; RETURN_PROFILE(0); } ocrLocation_t loc = 0; ocrFatGuid_t fatGuid = {.guid=guid, .metaDataPtr=NULL}; guidLocation(pd, fatGuid, &loc); //Current implementation doesn't store affinities of GUIDs //So we resolve the affinity of the GUID by looking up its //location and use that to index into the affinity array. //NOTE: Shortcoming is that it assumes location are integers. ASSERT(((u32)loc) < platformModel->pdLocAffinitiesSize); affinities[0] = platformModel->pdLocAffinities[(u32)loc]; } RETURN_PROFILE(0); }
int vfswrap_chmod(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode) { int result; START_PROFILE(syscall_chmod); /* * We need to do this due to the fact that the default POSIX ACL * chmod modifies the ACL *mask* for the group owner, not the * group owner bits directly. JRA. */ { int saved_errno = errno; /* We might get ENOSYS */ if ((result = SMB_VFS_CHMOD_ACL(conn, path, mode)) == 0) { END_PROFILE(syscall_chmod); return result; } /* Error - return the old errno. */ errno = saved_errno; } result = chmod(path, mode); END_PROFILE(syscall_chmod); return result; }
int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode) { int result; START_PROFILE(syscall_fchmod); /* * We need to do this due to the fact that the default POSIX ACL * chmod modifies the ACL *mask* for the group owner, not the * group owner bits directly. JRA. */ { int saved_errno = errno; /* We might get ENOSYS */ if ((result = SMB_VFS_FCHMOD_ACL(fsp, fd, mode)) == 0) { END_PROFILE(syscall_fchmod); return result; } /* Error - return the old errno. */ errno = saved_errno; } #if defined(HAVE_FCHMOD) result = fchmod(fd, mode); #else result = -1; errno = ENOSYS; #endif END_PROFILE(syscall_fchmod); return result; }
SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, int filedes, SMB_OFF_T offset, int whence) { SMB_OFF_T result = 0; START_PROFILE(syscall_lseek); /* Cope with 'stat' file opens. */ if (filedes != -1) result = sys_lseek(filedes, offset, whence); /* * We want to maintain the fiction that we can seek * on a fifo for file system purposes. This allows * people to set up UNIX fifo's that feed data to Windows * applications. JRA. */ if((result == -1) && (errno == ESPIPE)) { result = 0; errno = 0; } END_PROFILE(syscall_lseek); return result; }
int vfswrap_mkdir(vfs_handle_struct *handle, connection_struct *conn, const char *path, mode_t mode) { int result; BOOL has_dacl = False; START_PROFILE(syscall_mkdir); if (lp_inherit_acls(SNUM(conn)) && (has_dacl = directory_has_default_acl(conn, parent_dirname(path)))) mode = 0777; result = mkdir(path, mode); if (result == 0 && !has_dacl) { /* * We need to do this as the default behavior of POSIX ACLs * is to set the mask to be the requested group permission * bits, not the group permission bits to be the requested * group permission bits. This is not what we want, as it will * mess up any inherited ACL bits that were set. JRA. */ int saved_errno = errno; /* We may get ENOSYS */ if ((SMB_VFS_CHMOD_ACL(conn, path, mode) == -1) && (errno == ENOSYS)) errno = saved_errno; } END_PROFILE(syscall_mkdir); return result; }
void SoundSystem::TriggerEvent( SoundObjectId _objId, char *_eventName ) { if( !m_channels ) return; START_PROFILE("TriggerEvent"); char *objectType = m_interface->GetObjectType(_objId); if( objectType ) { SoundEventBlueprint *seb = m_blueprints.GetBlueprint(objectType); if( seb ) { for( int i = 0; i < seb->m_events.Size(); ++i ) { SoundInstanceBlueprint *sib = seb->m_events[i]; if( stricmp( sib->m_eventName, _eventName ) == 0 ) { Vector3<float> pos, vel; m_interface->GetObjectPosition( _objId, pos, vel ); SoundInstance *instance = new SoundInstance(); instance->Copy( sib->m_instance ); instance->m_objIds.PutData( _objId ); instance->m_pos = pos; instance->m_vel = vel; bool success = InitialiseSound ( instance ); if( !success ) ShutdownSound ( instance ); } } } } END_PROFILE("TriggerEvent"); }
void LandscapeRenderer::Render() { if (m_verts.Size() <= 0) return; g_app->m_location->SetupFog(); glEnable (GL_FOG); START_PROFILE( "Render Landscape Main"); switch (m_renderMode) { case RenderModeDisplayList: { int id = g_app->m_resource->GetDisplayList(MAIN_DISPLAY_LIST_NAME); AppDebugAssert(id != -1); glCallList(id); } break; default: RenderMainSlow(); break; } END_PROFILE( "Render Landscape Main"); int landscapeDetail = 1;//g_prefsManager->GetInt( "RenderLandscapeDetail", 1 ); if( landscapeDetail < 4 ) { START_PROFILE( "Render Landscape Overlay"); switch (m_renderMode) { case RenderModeDisplayList: { int id = g_app->m_resource->GetDisplayList(OVERLAY_DISPLAY_LIST_NAME); AppDebugAssert(id != -1); glCallList(id); } break; default: RenderOverlaySlow(); ; } END_PROFILE( "Render Landscape Overlay"); } glDisable (GL_FOG); }
long vfswrap_telldir(vfs_handle_struct *handle, connection_struct *conn, SMB_STRUCT_DIR *dirp) { long result; START_PROFILE(syscall_telldir); result = sys_telldir(dirp); END_PROFILE(syscall_telldir); return result; }
static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 share_mode) { START_PROFILE(syscall_kernel_flock); kernel_flock(fd, share_mode); END_PROFILE(syscall_kernel_flock); return 0; }
void Tripod::AdvanceWalk() { START_PROFILE(g_app->m_profiler, "AdvanceWalk"); // Consider mode switch { float timeSinceAttack = g_gameTime - m_modeStartTime; if (timeSinceAttack > 10.0f + ATTACK_DURATION) { WorldObjectId targetId = FindEntityToAttack(); if (targetId.IsValid()) { Entity *target = g_app->m_location->GetEntity(targetId); m_attackTarget = target->m_pos; m_mode = ModePreAttack; m_modeStartTime = g_gameTime; END_PROFILE(g_app->m_profiler, "AdvanceWalk"); return; } } } // Consider choosing a different nav dest if (syncrand() % 40 == 1) { m_navData.m_targetPos = ChooseDestination(); } // Hover m_targetHoverHeight = STATIONARY_HOVER_HEIGHT - fabsf(m_speed) * HOVER_LOWER_WITH_SPEED_FACTOR; // Navigate DoNavigation(); // Fall { bool allOnGround = m_legs[0]->m_foot.m_state == EntityFoot::OnGround && m_legs[1]->m_foot.m_state == EntityFoot::OnGround && m_legs[2]->m_foot.m_state == EntityFoot::OnGround; if (!allOnGround) { DoFallForTwoLegs(); } else { m_bodyVel.Zero(); m_front.HorizontalAndNormalise(); m_up = g_upVector; } } END_PROFILE(g_app->m_profiler, "AdvanceWalk"); }