MojErr MojDbKind::update(MojObject* newObj, const MojObject* oldObj, MojDbOp op, MojDbReq& req, bool checkSchema) { MojLogTrace(s_log); MojErr err = checkPermission(op, req); MojErrCheck(err); err = req.curKind(this); MojErrCheck(err); #if defined(TESTDBKIND) MojString s; MojErr e2; if (oldObj) { e2 = oldObj->toJson(s); MojLogInfo(s_log, _T("Kind_Update_OldObj: %s ;\n"), s.data()); } if (newObj) { e2 = newObj->toJson(s); MojLogInfo(s_log, _T("Kind_Update_NewObj: %s ;\n"), s.data()); } #endif if (newObj) { // add the _backup property if not set if (m_backup && !newObj->contains(MojDb::SyncKey)) { err = newObj->putBool(MojDb::SyncKey, true); MojErrCheck(err); } // TEMPORARY!!! This should be done in pre-update to also check parent kinds // warning message comes from preUpdate if(checkSchema) { MojSchema::Result res; err = m_schema.validate(*newObj, res); MojErrCheck(err); if (!res.valid()) { MojErrThrowMsg(MojErrSchemaValidation, _T("schema validation failed for kind '%s': %s"), m_id.data(), res.msg().data()); } } } // update revSets and validate schema err = preUpdate(newObj, oldObj, req); MojErrCheck(err); // update indexes MojVector<MojDbKind*> kindVec; MojInt32 idxcount = 0; err = updateIndexes(newObj, oldObj, req, op, kindVec, idxcount); MojLogInfo(s_log, _T("Kind_UpdateIndexes_End: %s; supers = %zu; indexcount = %zu; updated = %d \n"), this->id().data(), m_supers.size(), m_indexes.size(), idxcount); MojErrCheck(err); return MojErrNone; }
void System::update() { preUpdate(); auto it = entities.begin(); while(it != entities.end()){ updateEntity(**it); it++; } postUpdate(); }
bool CommonBfJlModules::delayedExpand(NodePtr pNode) { assert(m_pBfsHandler != nullptr); if (pNode->isRoot()) return false; NodePtr pParent = pNode->getParent(); if (pParent->getSequence() < getJobLevelRoot()->getSequence() || m_pBfsHandler->shouldDelayedExpand(pNode) == false) return false; if (dispatch(pParent)) { preUpdate(pParent); return true; } return false; }
bool QPSolver::solve(const rbd::MultiBody& mb, rbd::MultiBodyConfig& mbc) { preUpdate(mb, mbc); bool success = solver_->solve(); if(!success) { solver_->errorMsg(mb, tasks_, eqConstr_, inEqConstr_, genInEqConstr_, boundConstr_, std::cerr) << std::endl; } postUpdate(mb, mbc, success); return success; }
void View::doUpdate() { if (g_gameSystem->isRunning()) { return; } uint_t now = OsUtil::milliseconds(); m_frameTime = now - m_frameOldTime; m_frameOldTime = now; if (m_frameTime > 2000) { // Printf("DEBUG"); } preUpdate(); m_camera.setTarget(m_frame->getRenderTarget()); m_camera.setViewRect(m_frame->getRenderTarget()->getRect()); m_camera.setOrigin(m_eyeMatrix.origin); m_camera.setViewAxis(m_eyeMatrix.axis); m_camera.setFov(0, 60); m_camera.setTime(now); g_renderSystem->beginFrame(m_camera.getTarget()); #if 0 gRenderSystem->beginScene(m_camera); #endif if (!m_context->isLoading()) { doRender(); } #if 0 gRenderSystem->endScene(); #endif drawAxis(); //t = Milliseconds(); g_renderSystem->endFrame(); m_frameNumCur++; }
void Scene::updateBase(const float deltaTime) { if (isActive()) { const float dt = deltaTime * m_deltaScale; // Have to check every step since engine state // might be changed at any time if (Engine::getState() == Engine::State::Running) preUpdate(dt); if (Engine::getState() == Engine::State::Running) Object::update(dt); if (detail::CullerComponent::cullingEnabled() && Engine::getState() < Engine::State::Frozen) m_cullingWorld.update(1.f / 60.f); if (Engine::getState() == Engine::State::Running) postUpdate(dt); } }
void NormalDelete(pBtree p,int key) { int pos; pos=Find(p->Key,1,p->Sum,key); if(IsLeaf(p)) { if(Equal(p,pos,key)) { Delete(p,pos); } return; } else { if(Equal(p,pos,key)) { if(NodeAvailable(p->Child[pos-1])) { key=preUpdate(p,pos); NormalDelete(p->Child[pos-1],key); } else if(NodeAvailable(p->Child[pos])) { key=postUpdate(p,pos); NormalDelete(p->Child[pos],key); } else { Union(p,pos); NormalDelete(p->Child[pos-1],key); } } else { if(NodeAvailable(p->Child[pos-1])) { NormalDelete(p->Child[pos-1],key); } else { if(Exist(pos-2,p)&&NodeAvailable(p->Child[pos-2])) { rightFix(pos-2,p,pos-1); NormalDelete(p->Child[pos-1],key); } else if(Exist(pos,p)&&NodeAvailable(p->Child[pos])) { leftFix(pos-1,p,pos); NormalDelete(p->Child[pos-1],key); } else if(Exist(pos-2,p)) { Union(p,pos-1); NormalDelete(p->Child[pos-2],key); } else { Union(p,pos); NormalDelete(p->Child[pos-1],key); } } } } }
void VisualizationManager::onUpdate() { ros::WallDuration wall_diff = ros::WallTime::now() - last_update_wall_time_; ros::Duration ros_diff = ros::Time::now() - last_update_ros_time_; float wall_dt = wall_diff.toSec(); float ros_dt = ros_diff.toSec(); last_update_ros_time_ = ros::Time::now(); last_update_wall_time_ = ros::WallTime::now(); //ROS_INFO("time since last update: %fs", wall_dt); if(ros_dt < 0.0) { resetTime(); } ros::spinOnce(); Q_EMIT preUpdate(); frame_manager_->update(); root_display_group_->update( wall_dt, ros_dt ); view_manager_->update(wall_dt, ros_dt); time_update_timer_ += wall_dt; if( time_update_timer_ > 0.1f ) { time_update_timer_ = 0.0f; updateTime(); } frame_update_timer_ += wall_dt; if(frame_update_timer_ > 1.0f) { frame_update_timer_ = 0.0f; updateFrames(); } selection_manager_->update(); if( tool_manager_->getCurrentTool() ) { tool_manager_->getCurrentTool()->update(wall_dt, ros_dt); } if ( view_manager_ && view_manager_->getCurrent() && view_manager_->getCurrent()->getCamera() ) { directional_light_->setDirection(view_manager_->getCurrent()->getCamera()->getDerivedDirection()); } frame_count_++; //ROS_INFO("rviz/scenegraph update completed"); if ( render_requested_ || wall_dt > 0.01 ) { render_requested_ = 0; boost::mutex::scoped_lock lock(private_->render_mutex_); if ( render_panel_list_.size() == 0 ) ogre_root_->renderOneFrame(); for ( int i = 0; i < render_panel_list_.size(); i++ ) { if( render_panel_render_mask_[i] ) { active_view_id_ = i; render_panel_list_[i]->getRenderWindow()->update(true); } } } //ROS_INFO("finished rendering one frame"); }
void System::update(double dt) { preUpdate(); do_update(dt); postUpdate(); }
void AdvancedImageWidget::forceUpdate() { emit preUpdate(); mUi->widget->update(); }
bool Charts::Chart::update(void) { preUpdate(); const glm::float_t width = this->size.width; const glm::float_t height = this->size.height; if (!TR_VERIFY(width > 0.0 && height > 0.0)) { return false; } bool changed = false; if (title) { changed = changed || title->versionChanged(); } Margin internalMargin; for (auto axis : axisList) { addAxisInternalMargin(internalMargin, axis); } renderArgs.margin = Margin::add(margin, internalMargin); if (renderArgs.screenSize.x != width || renderArgs.screenSize.y != height) { if(!doRelayout) { const glm::vec2 marginProjection(renderArgs.margin.left + renderArgs.margin.right, renderArgs.margin.top + renderArgs.margin.bottom); const glm::vec2 newSize(width - marginProjection.x, height - marginProjection.y); if (resizeMode == ResizeMode::Rescale) { if (renderArgs.screenSize.x > 0.0 && renderArgs.screenSize.y > 0.0) { const glm::vec2 oldSize(renderArgs.screenSize.x - marginProjection.x, renderArgs.screenSize.y - marginProjection.y); scale *= (newSize / oldSize); } else { offset = glm::vec2(0.f); scale = newSize; } } else if (resizeMode == ResizeMode::Relayout) { offset = glm::vec2(0.f); scale = newSize; } } renderArgs.screenSize = glm::vec2(width, height); renderArgs.contentScaleFactor = contentScaleFactor; renderArgs.projection = glm::ortho(0.f, renderArgs.screenSize.x, 0.f, renderArgs.screenSize.y, -1000.f, +1000.f); } if (glm::float_t(contentScaleFactor) != renderArgs.contentScaleFactor) { renderArgs.contentScaleFactor = contentScaleFactor; } renderArgs.areaStart = glm::vec2(renderArgs.margin.left, renderArgs.margin.bottom); renderArgs.areaSize = renderArgs.screenSize - glm::vec2(renderArgs.margin.left + renderArgs.margin.right, renderArgs.margin.top + renderArgs.margin.bottom); if (doRelayout) { offset = glm::dvec2(0.f); scale = renderArgs.areaSize; doRelayout = false; } else { applyAnimations(); applyConstraints(); } // must check this AFTER applying animations and constraints changed = changed || versionChanged(); renderArgs.offset = offset; renderArgs.scale = scale; renderArgs.clearColor = Utils::colorToVec4(backgroundColor); for (auto axis : axisList) { //if (axis->isEnabled()) { changed |= axis->update(renderArgs); //} } for (auto series : seriesList) { //if (series->isEnabled()) { changed |= series->update(renderArgs); //} } for (auto decoration : decorationList) { //if (decoration->isEnabled()) { changed |= decoration->update(renderArgs); //} } if (!preRendered) { // we mark the chart as changed if it has not been pre-rendered, the purpose of the update changed value is // conditional rendering and if we update twice before calling render we will still need to render again. changed = true; } if(changed) { preRendered = false; } preUpdated = false; markVersion(); if (title) { title->markVersion(); } updated = true; return changed; }
void TransformableMarkerOperatorAction::onInitialize() { connect( vis_manager_, SIGNAL( preUpdate() ), this, SLOT( update() )); updateObjectArrayTopic(); }