static ObjectPtr convertObject(ObjectPtr x) { switch (x->objKind) { case RECORD : { Record *y = (Record *)x.ptr(); if (y->params.empty() && !y->varParam.ptr()) return recordType(y, vector<ObjectPtr>()).ptr(); return x; } case VARIANT : { Variant *y = (Variant *)x.ptr(); if (y->params.empty() && !y->varParam.ptr()) return variantType(y, vector<ObjectPtr>()).ptr(); return x; } default : return x; } }
//----------------------------------------------------------------------- void Scene::addObject(const ObjectPtr& object) { if (!mObjects.get<by_identity>().insert(object).second) { OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "The given object with name '" + object->getName() + "' already contain by this scene", "Scene::addObject"); } }
void AddLightObjectPlugin::onAddObject(const ObjectPtr& object) { Ogre::String type = object->getType(); // 判断,如果是能处理的类型(LightObject),就处理 if ( type == "Light" ) { LightObject *lightObject = static_cast<LightObject *> (object.get()); Indicator *indicator = new Indicator(object,mSceneManipulator->getSceneManager(), mSceneManipulator ); std::pair<Indicators::iterator, bool> inserted = mIndicators.insert(Indicators::value_type(object, indicator)); assert(inserted.second); } }
//----------------------------------------------------------------------- void Scene::removeObject(const ObjectPtr& object) { if (mObjects.get<by_identity>().erase(object) <= 0) { OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "The given object with name '" + object->getName() + "' doesn't contain by this scene", "Scene::removeObject"); } }
TEST(ObjectTests, NilObject) { ObjectPtr object = createObject(); ASSERT_EQ(Object::NIL, object->getNativeType()); ASSERT_TRUE(object->isNil()); ASSERT_EQ(false, object->getBoolean()); ASSERT_EQ(0.f, object->getNumber()); ASSERT_TRUE(object->getString().empty()); ASSERT_EQ(0, object->getUserdata()); ASSERT_STREQ("nil", object->getReadableString().c_str()); }
void SceneBrowser::OnContextMenu( ObjectPtr &object, wxTreeEvent& event ) { const Ogre::String &type = object->getType(); if ( type == "Actor" ) { ActorAnimationSettingDialog *dlg = new ActorAnimationSettingDialog(this, wxID_ANY, _("ActorAnimationSetting Dialog"), object, mSceneManipulator, event.GetPoint()); int result = dlg->Show(true); //if (result == wxID_CANCEL) //{ // // 如果异常列表中仍有内容,就给出提示 // if (dlg->mListBox->GetCount() > 0) // { // wxMessageBox(_("Thera are still some wrongs in scene,remember to fix them!")); // } // else // { // wxMessageBox(_("All wrongs in scene have been fixed,remember to save the scene!")); // } //} } else if ( type == "Effect" ) { Fairy::Effect *effect = static_cast<Fairy::EffectObject *>(object.get())->getEffect(); if ( effect ) { if ( NULL == mEffectDialog ) { mEffectDialog = new WXEffectEditDialog(this, wxID_ANY, _("Effect Setting")); } if ( false == mEffectDialog->IsShown() ) mEffectDialog->Show(); mEffectDialog->InitEffectDialog(effect, mSceneManipulator); } } mSceneManipulator->setActiveAction(NULL); }
DX11DeferredRendererMaterial::DX11DeferredRendererMaterial(const ObjectPtr<DX11Material>& base_material) : material_(base_material->Instantiate()){ auto& resources = DX11Graphics::GetInstance().GetResources(); shader_parameters_ = resources.Load<IStructuredBuffer, IStructuredBuffer::FromSize>({ sizeof(ShaderParameters) }); material_->SetInput(kShaderParameters, ObjectPtr<IStructuredBuffer>(shader_parameters_)); }
void ObjectSet::insert(ObjectPtr object) { std::pair<ObjectSet::SetType::iterator, bool> result = objects.insert(object); if (result.second) { objectMap[object->getId()] = result.first; } }
IException* User::Channel::SendAndReceive(TypeInfo::MethodAttributes_t attribs, Remoting::IMessage* pSend, Remoting::IMessage*& pRecv) { // Get the object manager OOBase::Guard<OOBase::SpinLock> guard(m_lock); ObjectPtr<Remoting::IMarshaller> ptrMarshaller = m_ptrMarshaller; if (!ptrMarshaller) throw Remoting::IChannelClosedException::Create(OMEGA_CREATE_INTERNAL("SendAndReceive() called on disconnected channel")); guard.release(); // We need to wrap the message ObjectPtr<ObjectImpl<OOCore::CDRMessage> > ptrEnvelope = ObjectImpl<OOCore::CDRMessage>::CreateObject(); ptrMarshaller->MarshalInterface(string_t::constant("payload"),ptrEnvelope,OMEGA_GUIDOF(Remoting::IMessage),pSend); OOBase::CDRStream response; try { OOServer::MessageHandler::io_result::type res = Manager::instance()->send_request(m_channel_id,ptrEnvelope->GetCDRStream(),&response,attribs); if (res != OOServer::MessageHandler::io_result::success) { if (res == OOServer::MessageHandler::io_result::channel_closed) { disconnect(); throw Omega::Remoting::IChannelClosedException::Create(OMEGA_CREATE_INTERNAL("Failed to send request")); } disconnect(); OMEGA_THROW("Internal server exception"); } } catch (...) { ptrMarshaller->ReleaseMarshalData(string_t::constant("payload"),ptrEnvelope,OMEGA_GUIDOF(Remoting::IMessage),pSend); throw; } if (!(attribs & TypeInfo::Asynchronous)) { try { // Wrap the response ObjectPtr<ObjectImpl<OOCore::CDRMessage> > ptrRecv = ObjectImpl<OOCore::CDRMessage>::CreateObject(); ptrRecv->init(response); // Unwrap the payload... IObject* pObj = NULL; ptrMarshaller->UnmarshalInterface(string_t::constant("payload"),ptrRecv,OMEGA_GUIDOF(Remoting::IMessage),pObj); pRecv = static_cast<Remoting::IMessage*>(pObj); } catch (IException* pE) { return pE; } } return NULL; }
void printStaticName(llvm::raw_ostream &out, ObjectPtr x) { if (x->objKind == IDENTIFIER) { Identifier *y = (Identifier *)x.ptr(); out << y->str; } else { printName(out, x); } }
bool Inside_Object (const Vector3d& IPoint, ObjectPtr Object, TraceThreadData *Thread) { for (vector<ObjectPtr>::iterator Sib = Object->Clip.begin(); Sib != Object->Clip.end(); Sib++) { if(!Inside_Object(IPoint, *Sib, Thread)) return false; } return (Object->Inside(IPoint, Thread)); }
void HistogramDialog::configureTab(ObjectPtr object) { if (!object) { _histogramTab->setRealTimeAutoBin(dialogDefaults().value("histogram/realTimeAutoBin", false).toBool()); _histogramTab->setNormalizationType(Histogram::NormalizationType(dialogDefaults().value("histogram/normalizationType",Histogram::Number).toInt())); } else if (HistogramPtr histogram = kst_cast<Histogram>(object)) { _histogramTab->setVector(histogram->vector()); _histogramTab->setMin(histogram->xMin()); _histogramTab->setMax(histogram->xMax()); _histogramTab->setBins(histogram->numberOfBins()); _histogramTab->setRealTimeAutoBin(histogram->realTimeAutoBin()); _histogramTab->setNormalizationType(histogram->normalizationType()); _histogramTab->hideCurveOptions(); if (_editMultipleWidget) { HistogramList objects = _document->objectStore()->getObjects<Histogram>(); _editMultipleWidget->clearObjects(); foreach(HistogramPtr object, objects) { _editMultipleWidget->addObject(object->Name(), object->descriptionTip()); } }
void Player::SetAgent( sf::Uint16 id ) { m_tentative_agent_id = id; ObjectPtr object = Game::GetGame()->GetObjectManager()->GetObjectById( id ); if( !object ) { return; } if( object->GetType() != ObjectType::SHIP ) { return; } ShipPtr agent = std::static_pointer_cast<Ship>( Game::GetGame()->GetObjectManager()->GetObjectById( id ) ); agent->SetPlayer( true ); LogConsole( "Set player ship to object: " + string_cast( id ) ); m_tentative_agent_id = 0xffff; m_agent = agent; }
void ArchiveBinary::DeserializeInstance(ObjectPtr& object) { // // If we don't have an object allocated for deserialization, pull one from the stream // if (!object.ReferencesObject()) { object = Allocate(); } // // We should now have an instance (unless data was skipped) // if (object.ReferencesObject()) { #ifdef REFLECT_ARCHIVE_VERBOSE m_Indent.Get(stdout); Log::Print(TXT("Deserializing %s\n"), object->GetClass()->m_Name); m_Indent.Push(); #endif object->PreDeserialize( NULL ); Data* data = SafeCast<Data>(object); if ( data ) { data->Deserialize(*this); } else { DeserializeFields(object); } object->PostDeserialize( NULL ); #ifdef REFLECT_ARCHIVE_VERBOSE m_Indent.Pop(); #endif } }
void throwUOE(const string& expectedType, const ObjectPtr& v) { // // If the object is an unknown sliced object, we didn't find an // object factory, in this case raise a NoObjectFactoryException // instead. // UnknownSlicedObject* uso = dynamic_cast<UnknownSlicedObject*>(v.get()); if(uso) { throw NoObjectFactoryException(__FILE__, __LINE__, "", uso->getUnknownTypeId()); } string type = v->ice_id(); throw Ice::UnexpectedObjectException(__FILE__, __LINE__, "expected element of type `" + expectedType + "' but received '" + type, type, expectedType); }
void CurveDialog::configureTab(ObjectPtr object) { if (!object) { _curveTab->curveAppearance()->loadWidgetDefaults(); _curveTab->setToLastX(); } else if (CurvePtr curve = kst_cast<Curve>(object)) { _curveTab->curveAppearance()->loadWidgetDefaults(); _curveTab->setXVector(curve->xVector()); _curveTab->setYVector(curve->yVector()); if (curve->hasXError()) { _curveTab->setXError(curve->xErrorVector()); } if (curve->hasYError()) { _curveTab->setYError(curve->yErrorVector()); } if (curve->hasXMinusError()) { _curveTab->setXMinusError(curve->xMinusErrorVector()); } if (curve->hasYMinusError()) { _curveTab->setYMinusError(curve->yMinusErrorVector()); } _curveTab->setIgnoreAutoScale(curve->ignoreAutoScale()); _curveTab->curveAppearance()->setColor(curve->color()); _curveTab->curveAppearance()->setHeadColor(curve->headColor()); _curveTab->curveAppearance()->setShowPoints(curve->hasPoints()); _curveTab->curveAppearance()->setShowLines(curve->hasLines()); _curveTab->curveAppearance()->setShowBars(curve->hasBars()); _curveTab->curveAppearance()->setShowHead(curve->hasHead()); _curveTab->curveAppearance()->setLineWidth(curve->lineWidth()); _curveTab->curveAppearance()->setPointSize(curve->pointSize()); _curveTab->curveAppearance()->setLineStyle(curve->lineStyle()); _curveTab->curveAppearance()->setPointType(curve->pointType()); _curveTab->curveAppearance()->setPointDensity(curve->pointDensity()); _curveTab->curveAppearance()->setBarFillColor(curve->barFillColor()); _curveTab->curveAppearance()->setHeadType(curve->headType()); _curveTab->hidePlacementOptions(); if (_editMultipleWidget) { CurveList objects = _document->objectStore()->getObjects<Curve>(); _editMultipleWidget->clearObjects(); foreach(CurvePtr object, objects) { _editMultipleWidget->addObject(object->Name(), object->descriptionTip()); } }
void Scene::eraseObject(ObjectPtr pObject) { SIACheckRet(!pObject); SIAAssert(m_pGameLayer); auto pEntity = pObject->entity(); SIAAssert(pEntity); m_modelController.addCommand(std::make_shared<Commands::EraseEntity>(pEntity), [pObject, this] () { auto pView = pObject->view(); SIAAssert(pView); m_pGameLayer->eraseGameView(pView); m_pObjects.erase(std::remove_if(m_pObjects.begin(), m_pObjects.end(), [&pObject] (ObjectPtr& pObj) { return pObject.get() == pObj.get(); }), m_pObjects.end()); SIADebug("Removed object from scene."); }, nullptr); }
ObjectPtr Copy_Object (ObjectPtr Old) { ObjectPtr New; if(Old == NULL) return NULL; New = Old->Copy(); /* * The following copying of OBJECT_FIELDS is redundant if Copy * did *New = *Old but we cannot assume it did. It is safe for * Copy to do *New = *Old but it should not otherwise * touch OBJECT_FIELDS. */ New->Type = Old->Type; New->Bound = Old->Bound; New->Clip = Old->Clip; New->BBox = Old->BBox; New->Flags = Old->Flags; New->Ph_Density = Old->Ph_Density; New->RadiosityImportance = Old->RadiosityImportance; // TODO FIXME - An explanation WHY this is important would be nice [CLi] New->LLights.clear(); // important New->Texture = Copy_Textures (Old->Texture); New->Interior_Texture = Copy_Textures (Old->Interior_Texture); if(Old->interior != NULL) New->interior = InteriorPtr(new Interior(*(Old->interior))); else New->interior.reset(); // TODO: we really ought to decide whether or not it's useful to maintain // the overhead of having multiple clip and bound objects ... it is // after all possible for the user to use CSG and give us one object // meaning we could use a plain pointer here. if (Old->Bound.empty() == false) New->Bound = Copy_Objects(Old->Bound); if (Old->Clip.empty() == false) { // note that in this case the objects are shared and should only be // destroyed the once !!! ... to be frank POV really needs a reference- // counted system for sharing objects with copy-on-write semantics. if(Old->Bound != Old->Clip) New->Clip = Copy_Objects(Old->Clip); else New->Clip = New->Bound; } return New; }
void Freeze::BackgroundSaveEvictorI::finished(const Current& current, const ObjectPtr& servant, const LocalObjectPtr& cookie) { assert(servant != 0); DeactivateController::Guard deactivateGuard(_deactivateController); if(cookie != 0) { BackgroundSaveEvictorElementPtr element = BackgroundSaveEvictorElementPtr::dynamicCast(cookie); assert(element); bool enqueue = false; if((servant->ice_operationAttributes(current.operation) & 0x1) != 0) { IceUtil::Mutex::Lock lock(element->mutex); if(element->status == clean) { // // Assume this operation updated the object // element->status = modified; enqueue = true; } } Lock sync(*this); // // Only elements with a usageCount == 0 can become stale and we own // one count! // assert(!element->stale); assert(element->usageCount >= 1); // // Decrease the usage count of the evictor queue element. // element->usageCount--; if(enqueue) { addToModifiedQueue(element); } else if(element->usageCount == 0 && element->keepCount == 0) { // // Evict as many elements as necessary. // evict(); } } }
VALUE array_inspect(const CallFrame* here, VALUE self, VALUE it) { ObjectPtr<Array> array = self; if (array == NULL) { throw_exception_with_description("Array#inspect called for object that doesn't derive from Array."); } ObjectPtr<String> result = create_string_constant("@("); for (size_t i = 0; i < array->size(); ++i) { Value val = (*array)[i]; string_append(result, value_inspect(val)); if (i != array->size() - 1) { string_append_cstr(result, ", "); } } string_append_cstr(result, ")"); return result; }
static vector<TypePtr> typesOfValues(ObjectPtr obj) { vector<TypePtr> types; switch (obj->objKind) { case MULTI_PVALUE : { MultiPValue *mpv = (MultiPValue *)obj.ptr(); for (unsigned i = 0; i < mpv->size(); ++i) types.push_back(mpv->values[i]->type); break; } case MULTI_CVALUE : { MultiCValue *mcv = (MultiCValue *)obj.ptr(); for (unsigned i = 0; i < mcv->size(); ++i) types.push_back(mcv->values[i]->type); break; } default : assert(false); } return types; }
inline void onEvent(Event& event) { if(object_) { object_->onEvent(*this, event); } typedef std::map<std::string, NodePtr>::iterator ItType; for(ItType it = children_.begin(); it != children_.end(); ++it) { it->second->onEvent(event); } }
//----------------------------------------------------------------------- void CreateObjectOperator::add(const ObjectPtr& object, bool create) { assert(object); mObjectInfos.push_back(ObjectInfo()); ObjectInfo& info = mObjectInfos.back(); info.create = create; info.type = object->getType(); info.name = object->getName(); const PropertyList& properties = object->getProperties(); for (PropertyList::const_iterator it = properties.begin(); it != properties.end(); ++it) { const PropertyDef& propertyDef = *it; if (object->getPropertyAsString(propertyDef.name) != propertyDef.defaultValue) { info.properties.insert( PropertyNameVariantPairList::value_type(propertyDef.name, object->getProperty(propertyDef.name))); } } }
//----------------------------------------------------------------------- void CreateObjectOperator::apply(bool reserve) { for (ObjectInfoList::const_iterator i = mObjectInfos.begin(); i != mObjectInfos.end(); ++i) { const ObjectInfo& info = *i; if (reserve == info.create) { const ObjectPtr& object = mSceneManipulator->getSceneInfo()->findObjectByName(i->name); assert(object); mSceneManipulator->removeObject(object, NULL, true); } else { ObjectPtr object = ObjectFactoryManager::getSingleton().createInstance(info.type); object->setName(info.name); object->setPropertyList(info.properties); object->createRenderInstance(mSceneManipulator); mSceneManipulator->addObject(object, NULL, true); } } }
/* void GameMan::Unselect(List* objectList) { } */ void GameMan::Update(float dt) { for(ObjectTypeMap::const_iterator objTypeMap = m_objects.begin(); objTypeMap != m_objects.end(); objTypeMap++) { ObjectMap ObjMap = (*objTypeMap).second; std::stack<uint32_t> eraseStack; for(ObjectMap::const_iterator objMap = ObjMap.begin(); objMap != ObjMap.end(); objMap++) { ObjectPtr object = objMap->second; if (object->clearObject()) eraseStack.push(objMap->first); else object->update(dt); } while(!eraseStack.empty()) { ObjMap.erase(eraseStack.top()); eraseStack.pop(); } } }
const OverloadPtr callableInterface(ObjectPtr x) { switch (x->objKind) { case PROCEDURE : { Procedure *y = (Procedure *)x.ptr(); return y->interface; } default : { return NULL; } } }
// Run one item, return true if there are more items. bool active::scheduler::locked_run_one() { #ifdef ACTIVE_USE_CXX11 if(atomic_node * n = m_activated_objects.pop()) { static_cast<ObjectPtr>(n)->run_some(); return true; } #else if( m_head ) { ObjectPtr p = m_head; m_head=static_cast<ObjectPtr>(m_head->next); m_mutex.unlock(); p->run_some(); m_mutex.lock(); return true; } #endif return false; }
static void cmdOverloads(const vector<Token>& tokens) { for (size_t i = 1; i < tokens.size(); ++i) { if (tokens[i].tokenKind == T_IDENTIFIER) { Str identStr = tokens[i].str; ObjectPtr obj = lookupPrivate(module, Identifier::get(identStr)); if (obj == NULL || obj->objKind != PROCEDURE) { llvm::errs() << identStr << " is not a procedure name\n"; continue; } vector<InvokeSet*> sets = lookupInvokeSets(obj.ptr()); for (size_t k = 0; k < sets.size(); ++k) { llvm::errs() << " "; for (size_t l = 0; l < sets[k]->argsKey.size(); ++l) { llvm::errs() << sets[k]->argsKey[l] << " : "; } llvm::errs() << "\n"; } } } }
qlib::Vector4D RendGroup::getCenter() const { // Calc COM of renderers in this group Vector4D resvec; int nsum = 0; ObjectPtr pObj = getClientObj(); Object::RendIter iter = pObj->beginRend(); Object::RendIter eiter = pObj->endRend(); for (;iter!=eiter;++iter) { RendererPtr pRend = iter->second; if (!pRend->getGroupName().equals(getName())) continue; if (pRend->hasCenter()) { resvec += pRend->getCenter(); ++nsum; } } if (nsum>0) return resvec.divide(nsum); else return qlib::Vector4D(); }
QString ScriptInterface::doObjectCommand(QString command, ObjectPtr ob) { QString v=doNamedObjectCommand(command, ob); if (!v.isEmpty()) { return v; } if (command.startsWith("type(")) { return ob->typeString(); } return QString(); }