void CrowdManager::SetObstacleAvoidanceTypesAttr(const VariantVector& value) { if (!crowd_) return; unsigned index = 0; unsigned obstacleAvoidanceType = 0; numObstacleAvoidanceTypes_ = index < value.Size() ? Min(value[index++].GetUInt(), (unsigned)DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS) : 0; while (obstacleAvoidanceType < numObstacleAvoidanceTypes_) { if (index + 10 <= value.Size()) { dtObstacleAvoidanceParams params; params.velBias = value[index++].GetFloat(); params.weightDesVel = value[index++].GetFloat(); params.weightCurVel = value[index++].GetFloat(); params.weightSide = value[index++].GetFloat(); params.weightToi = value[index++].GetFloat(); params.horizTime = value[index++].GetFloat(); params.gridSize = (unsigned char)value[index++].GetUInt(); params.adaptiveDivs = (unsigned char)value[index++].GetUInt(); params.adaptiveRings = (unsigned char)value[index++].GetUInt(); params.adaptiveDepth = (unsigned char)value[index++].GetUInt(); crowd_->setObstacleAvoidanceParams(obstacleAvoidanceType, ¶ms); } ++obstacleAvoidanceType; } }
void AnimationController::SetNodeAnimationStatesAttr(const VariantVector& value) { ResourceCache* cache = GetSubsystem<ResourceCache>(); nodeAnimationStates_.Clear(); unsigned index = 0; unsigned numStates = index < value.Size() ? value[index++].GetUInt() : 0; // Prevent negative or overly large value being assigned from the editor if (numStates > M_MAX_INT) numStates = 0; if (numStates > MAX_NODE_ANIMATION_STATES) numStates = MAX_NODE_ANIMATION_STATES; nodeAnimationStates_.Reserve(numStates); while (numStates--) { if (index + 2 < value.Size()) { // Note: null animation is allowed here for editing const ResourceRef& animRef = value[index++].GetResourceRef(); SharedPtr<AnimationState> newState(new AnimationState(GetNode(), cache->GetResource<Animation>(animRef.name_))); nodeAnimationStates_.Push(newState); newState->SetLooped(value[index++].GetBool()); newState->SetTime(value[index++].GetFloat()); } else { // If not enough data, just add an empty animation state SharedPtr<AnimationState> newState(new AnimationState(GetNode(), 0)); nodeAnimationStates_.Push(newState); } } }
void ScriptInstance::HandlePhysicsPostStep(StringHash eventType, VariantMap& eventData) { if (!active_ || !scriptObject_) return; using namespace PhysicsPostStep; if (!fixedUpdateFps_) { VariantVector parameters; parameters.Push(eventData[P_TIMESTEP]); scriptFile_->Execute(scriptObject_, methods_[METHOD_FIXEDPOSTUPDATE], parameters); } else { float timeStep = eventData[P_TIMESTEP].GetFloat(); fixedPostUpdateAcc_ += timeStep; if (fixedPostUpdateAcc_ >= fixedUpdateInterval_) { fixedPostUpdateAcc_ = fmodf(fixedPostUpdateAcc_, fixedUpdateInterval_); VariantVector parameters; parameters.Push(fixedUpdateInterval_); scriptFile_->Execute(scriptObject_, methods_[METHOD_FIXEDPOSTUPDATE], parameters); } } }
// obtain read or write variables processed by all nested loops, if any void getVariablesProcessedByInnerLoops (SgScopeStatement* current_loop_body, bool isRead, std::set<SgInitializedName*>& var_set) { // AST query to find all loops // add all read/write variables into the var_set VariantVector vv; vv.push_back(V_SgForStatement); vv.push_back(V_SgFortranDo); Rose_STL_Container<SgNode*> nodeList = NodeQuery::querySubTree(current_loop_body, vv); for (Rose_STL_Container<SgNode *>::iterator i = nodeList.begin(); i != nodeList.end(); i++) { SgStatement* loop = isSgStatement(*i); if (debug) cout<< "Found nested loop at line:"<< loop->get_file_info()->get_line()<<endl; std::set<SgInitializedName*> src_var_set ; if (isRead) src_var_set = LoopLoadVariables[loop]; else src_var_set = LoopStoreVariables[loop]; std::set<SgInitializedName*>::iterator j; if (debug) cout<< "\t Insert processed variable:"<<endl; for (j= src_var_set.begin(); j!= src_var_set.end(); j++) { var_set.insert(*j); if (debug) cout<< "\t \t "<<(*j)->get_name()<<endl; } } }
void StaticModelGroup::SetNodeIDsAttr(const VariantVector& value) { // Just remember the node IDs. They need to go through the SceneResolver, and we actually find the nodes during // ApplyAttributes() if (value.Size()) { nodeIDsAttr_.Clear(); unsigned index = 0; unsigned numInstances = value[index++].GetUInt(); // Prevent crash on entering negative value in the editor if (numInstances > M_MAX_INT) numInstances = 0; nodeIDsAttr_.Push(numInstances); while (numInstances--) { // If vector contains less IDs than should, fill the rest with zeroes if (index < value.Size()) nodeIDsAttr_.Push(value[index++].GetUInt()); else nodeIDsAttr_.Push(0); } } else { nodeIDsAttr_.Clear(); nodeIDsAttr_.Push(0); } nodeIDsDirty_ = true; }
void CrowdManager::SetQueryFilterTypesAttr(const VariantVector& value) { if (!crowd_) return; unsigned index = 0; unsigned queryFilterType = 0; numQueryFilterTypes_ = index < value.Size() ? Min(value[index++].GetUInt(), (unsigned)DT_CROWD_MAX_QUERY_FILTER_TYPE) : 0; while (queryFilterType < numQueryFilterTypes_) { if (index + 3 <= value.Size()) { dtQueryFilter* filter = crowd_->getEditableFilter(queryFilterType); assert(filter); filter->setIncludeFlags((unsigned short)value[index++].GetUInt()); filter->setExcludeFlags((unsigned short)value[index++].GetUInt()); unsigned prevNumAreas = numAreas_[queryFilterType]; numAreas_[queryFilterType] = Min(value[index++].GetUInt(), (unsigned)DT_MAX_AREAS); // Must loop through based on previous number of areas, the new area cost (if any) can only be set in the next attribute get/set iteration if (index + prevNumAreas <= value.Size()) { for (unsigned i = 0; i < prevNumAreas; ++i) filter->setAreaCost(i, value[index++].GetFloat()); } } ++queryFilterType; } }
void ScriptEventInvoker::HandleScriptEvent(StringHash eventType, VariantMap& eventData) { if (!file_->IsCompiled()) return; asIScriptFunction* method = static_cast<asIScriptFunction*>(GetEventHandler()->GetUserData()); if (object_ && !IsObjectAlive()) { file_->CleanupEventInvoker(object_); return; } VariantVector parameters; if (method->GetParamCount() > 0) { parameters.Push(Variant((void*)&eventType)); parameters.Push(Variant((void*)&eventData)); } if (object_) file_->Execute(object_, method, parameters); else file_->Execute(method, parameters); }
//---------------------------------------------------------------------------- // InitializeContentScripting STDMETHODIMP CAnchoAddon::InitializeContentScripting(IWebBrowser2* pBrowser, BSTR bstrUrl, documentLoadPhase aPhase) { IF_FAILED_RET(initializeEnvironment()); // content script handling happens here // no frame handling // TODO: decide how to handle frames if (!m_pWebBrowser.IsEqualObject(pBrowser)) { return S_OK; } if (aPhase != documentLoadEnd) { return S_OK; } cleanupScripting(); // get content our API IF_FAILED_RET(m_pAddonBackground->GetContentInfo(m_InstanceID, bstrUrl, &m_pContentInfo)); CString s; s.Format(_T("Ancho content [%s] [%i]"), m_sExtensionName, m_InstanceID); IF_FAILED_RET(m_Magpie->Init((LPWSTR)(LPCWSTR)s)); // add a loader for scripts in the extension filesystem IF_FAILED_RET(m_Magpie->AddFilesystemScriptLoader((LPWSTR)(LPCWSTR)m_sExtensionPath)); // inject items: chrome, console and window with global members CComQIPtr<IWebBrowser2> pWebBrowser(pBrowser); ATLASSERT(pWebBrowser); CIDispatchHelper contentInfo(m_pContentInfo); CComVariant jsObj; IF_FAILED_RET((contentInfo.Get<CComVariant, VT_DISPATCH, IDispatch*>(L"api", jsObj))); IF_FAILED_RET(DOMWindowWrapper::createInstance(pWebBrowser, m_wrappedWindow)); m_Magpie->AddNamedItem(L"chrome", jsObj.pdispVal, SCRIPTITEM_ISVISIBLE|SCRIPTITEM_CODEONLY); m_Magpie->AddNamedItem(L"window", m_wrappedWindow, SCRIPTITEM_ISVISIBLE|SCRIPTITEM_GLOBALMEMBERS); CIDispatchHelper window = m_wrappedWindow; CComPtr<IDispatchEx> pRequest; IF_FAILED_RET(pRequest.CoCreateInstance(__uuidof(AnchoXmlHttpRequest))); IF_FAILED_RET(window.SetProperty((LPOLESTR)L"XMLHttpRequest", CComVariant(pRequest.p))); m_Magpie->AddNamedItem(L"XMLHttpRequest", pRequest, SCRIPTITEM_ISVISIBLE|SCRIPTITEM_CODEONLY); // get the name(s) of content scripts from manifest and run them in order IF_FAILED_RET((contentInfo.Get<CComVariant, VT_DISPATCH, IDispatch*>(L"scripts", jsObj))); VariantVector scripts; IF_FAILED_RET(addJSArrayToVariantVector(jsObj.pdispVal, scripts)); for(VariantVector::iterator it = scripts.begin(); it != scripts.end(); ++it) { if( it->vt == VT_BSTR ) { m_Magpie->ExecuteGlobal(it->bstrVal); } } return S_OK; }
bool Serializer::WriteVariantVector(const VariantVector& value) { bool success = true; success &= WriteVLE(value.Size()); for (VariantVector::ConstIterator i = value.Begin(); i != value.End(); ++i) success &= WriteVariant(*i); return success; }
VariantVector AnimatedModel::GetBonesEnabledAttr() const { VariantVector ret; const Vector<Bone>& bones = skeleton_.GetBones(); ret.Reserve(bones.Size()); for (Vector<Bone>::ConstIterator i = bones.Begin(); i != bones.End(); ++i) ret.Push(i->animated_); return ret; }
void ScriptInstance::SetScriptDataAttr(PODVector<unsigned char> data) { if (scriptObject_ && methods_[METHOD_LOAD]) { MemoryBuffer buf(data); VariantVector parameters; parameters.Push(Variant((void*)static_cast<Deserializer*>(&buf))); scriptFile_->Execute(scriptObject_, methods_[METHOD_LOAD], parameters); } }
void ScriptInstance::SetScriptNetworkDataAttr(const PODVector<unsigned char>& data) { if (scriptObject_ && methods_[METHOD_READNETWORKUPDATE]) { MemoryBuffer buf(data); VariantVector parameters; parameters.Push(Variant((void*)static_cast<Deserializer*>(&buf))); scriptFile_->Execute(scriptObject_, methods_[METHOD_READNETWORKUPDATE], parameters); } }
void AngelScriptIntegration::CreateScene() { ResourceCache* cache = GetSubsystem<ResourceCache>(); scene_ = new Scene(context_); // Create the Octree component to the scene so that drawable objects can be rendered. Use default volume // (-1000, -1000, -1000) to (1000, 1000, 1000) scene_->CreateComponent<Octree>(); // Create a Zone component into a child scene node. The Zone controls ambient lighting and fog settings. Like the Octree, // it also defines its volume with a bounding box, but can be rotated (so it does not need to be aligned to the world X, Y // and Z axes.) Drawable objects "pick up" the zone they belong to and use it when rendering; several zones can exist Node* zoneNode = scene_->CreateChild("Zone"); Zone* zone = zoneNode->CreateComponent<Zone>(); // Set same volume as the Octree, set a close bluish fog and some ambient light zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f)); zone->SetAmbientColor(Color(0.05f, 0.1f, 0.15f)); zone->SetFogColor(Color(0.1f, 0.2f, 0.3f)); zone->SetFogStart(10.0f); zone->SetFogEnd(100.0f); // Create randomly positioned and oriented box StaticModels in the scene const unsigned NUM_OBJECTS = 2000; for (unsigned i = 0; i < NUM_OBJECTS; ++i) { Node* boxNode = scene_->CreateChild("Box"); boxNode->SetPosition(Vector3(Random(200.0f) - 100.0f, Random(200.0f) - 100.0f, Random(200.0f) - 100.0f)); // Orient using random pitch, yaw and roll Euler angles boxNode->SetRotation(Quaternion(Random(360.0f), Random(360.0f), Random(360.0f))); StaticModel* boxObject = boxNode->CreateComponent<StaticModel>(); boxObject->SetModel(cache->GetResource<Model>("Models/Box.mdl")); boxObject->SetMaterial(cache->GetResource<Material>("Materials/Stone.xml")); // Add our custom Rotator script object (using the ScriptInstance C++ component to instantiate / store it) which will // rotate the scene node each frame, when the scene sends its update event ScriptInstance* instance = boxNode->CreateComponent<ScriptInstance>(); instance->CreateObject(cache->GetResource<ScriptFile>("Scripts/Rotator.as"), "Rotator"); // Call the script object's "SetRotationSpeed" function. Function arguments need to be passed in a VariantVector VariantVector parameters; parameters.Push(Vector3(10.0f, 20.0f, 30.0f)); instance->Execute("void SetRotationSpeed(const Vector3&in)", parameters); } // Create the camera. Let the starting position be at the world origin. As the fog limits maximum visible distance, we can // bring the far clip plane closer for more effective culling of distant objects cameraNode_ = scene_->CreateChild("Camera"); Camera* camera = cameraNode_->CreateComponent<Camera>(); camera->SetFarClip(100.0f); // Create a point light to the camera scene node Light* light = cameraNode_->CreateComponent<Light>(); light->SetLightType(LIGHT_POINT); light->SetRange(30.0f); }
void ScriptInstance::HandlePhysicsPostStep(StringHash eventType, VariantMap& eventData) { if (!scriptObject_) return; using namespace PhysicsPostStep; VariantVector parameters; parameters.Push(eventData[P_TIMESTEP]); scriptFile_->Execute(scriptObject_, methods_[METHOD_FIXEDPOSTUPDATE], parameters); }
void ScriptInstance::HandleScenePostUpdate(StringHash eventType, VariantMap& eventData) { if (!active_ || !scriptObject_) return; using namespace ScenePostUpdate; VariantVector parameters; parameters.Push(eventData[P_TIMESTEP]); scriptFile_->Execute(scriptObject_, methods_[METHOD_POSTUPDATE], parameters); }
VariantVector ParticleEmitter::GetColorsAttr() const { VariantVector ret; ret.Reserve(colorFrames_.Size() * 2 + 1); ret.Push(colorFrames_.Size()); for (Vector<ColorFrame>::ConstIterator i = colorFrames_.Begin(); i < colorFrames_.End(); ++i) { ret.Push(i->color_); ret.Push(i->time_); } return ret; }
VariantVector ParticleEmitter::GetTextureFramesAttr() const { VariantVector ret; ret.Reserve(textureFrames_.Size() * 2 + 1); ret.Push(textureFrames_.Size()); for (Vector<TextureFrame>::ConstIterator i = textureFrames_.Begin(); i < textureFrames_.End(); ++i) { ret.Push(i->uv_.ToVector4()); ret.Push(i->time_); } return ret; }
VariantVector XMLElement::GetVariantVector() const { VariantVector ret; XMLElement variantElem = GetChild("variant"); while (variantElem) { ret.push_back(variantElem.GetVariant()); variantElem = variantElem.GetNext("variant"); } return ret; }
PODVector<unsigned char> ScriptInstance::GetScriptDataAttr() const { if (!scriptObject_ || !methods_[METHOD_SAVE]) return PODVector<unsigned char>(); else { VectorBuffer buf; VariantVector parameters; parameters.Push(Variant((void*)static_cast<Serializer*>(&buf))); scriptFile_->Execute(scriptObject_, methods_[METHOD_SAVE], parameters); return buf.GetBuffer(); } }
//---------------------------------------------------------------------------- // HRESULT CAnchoAddonService::removeTabs(LPDISPATCH aTabs, LPDISPATCH aCallback) { VariantVector tabs; IF_FAILED_RET(addJSArrayToVariantVector(aTabs, tabs)); for(VariantVector::iterator it = tabs.begin(); it != tabs.end(); ++it) { if( it->vt == VT_I4 ) { removeTab(it->intVal, aCallback); } else { ATLTRACE(L"Problem with specified tabId - not an integer\n"); } } return S_OK; }
void registerAstSubtreeIds (SgNode* root) { // We only care about located nodes for now since they are visible to users in source code // we have to include SgProject and SgSourceFile nodes also. VariantVector vv; vv.push_back(V_SgProject); vv.push_back(V_SgSourceFile); vv.push_back(V_SgLocatedNode); Rose_STL_Container <SgNode*> nodeList = NodeQuery::querySubTree (root, vv); for (Rose_STL_Container <SgNode*>::iterator iter = nodeList.begin(); iter != nodeList.end(); iter++) { SgNode* n = (*iter); setId (n); } }
void ScriptInstance::HandleScriptEvent(StringHash eventType, VariantMap& eventData) { if (!active_ || !scriptFile_ || !scriptObject_) return; asIScriptFunction* method = static_cast<asIScriptFunction*>(GetEventHandler()->GetUserData()); VariantVector parameters; if (method->GetParamCount() > 0) { parameters.Push(Variant((void*)&eventType)); parameters.Push(Variant((void*)&eventData)); } scriptFile_->Execute(scriptObject_, method, parameters); }
void AnimationController::SetAnimationsAttr(VariantVector value) { animations_.Clear(); animations_.Reserve(value.Size() / 5); // Incomplete data is discarded unsigned index = 0; while (index + 4 < value.Size()) // Prevent out-of-bound index access { AnimationControl newControl; newControl.hash_ = value[index++].GetStringHash(); newControl.speed_ = value[index++].GetFloat(); newControl.targetWeight_ = value[index++].GetFloat(); newControl.fadeTime_ = value[index++].GetFloat(); newControl.autoFadeTime_ = value[index++].GetFloat(); animations_.Push(newControl); } }
/** * * We received a disconnect signal. Lets cleanup the connection in question * * @param args The arguments passed from the database * @return void */ void DatabaseConnectionManager::disconnected(const VariantVector &args) { DatabaseConnection *connection; std::string uuid; Variant uid = args.data()[0]; uuid = uid.toString(); // Find connection connection = disconnectingConnections[uuid]; // Stop running connection->stop(); // Wait for the connection to finish while (!connection->isFinished()) { // Process any pending events Application::getInstance()->processEvents(); // Sleep for 30ms. usleep(30 * 1000); } // Remove from collection disconnectingConnections.erase(uuid); // Free memory if (connection != mainConnection) { delete connection; } }
void ScriptFile::HandleScriptEvent(StringHash eventType, VariantMap& eventData) { if (!compiled_) return; asIScriptFunction* function = static_cast<asIScriptFunction*>(GetEventHandler()->GetUserData()); VariantVector parameters; if (function->GetParamCount() > 0) { parameters.Push(Variant((void*)&eventType)); parameters.Push(Variant((void*)&eventData)); } Execute(function, parameters); }
bool XMLElement::SetVariantVector(const VariantVector& value) { // Must remove all existing variant child elements (if they exist) to not cause confusion if (!RemoveChildren("variant")) return false; for (auto i = value.begin(); i != value.end(); ++i) { XMLElement variantElem = CreateChild("variant"); if (!variantElem) return false; variantElem.SetVariant(*i); } return true; }
void ScriptInstance::HandleSceneUpdate(StringHash eventType, VariantMap& eventData) { if (!active_ || !scriptObject_) return; using namespace SceneUpdate; float timeStep = eventData[P_TIMESTEP].GetFloat(); // Execute delayed method calls for (unsigned i = 0; i < delayedMethodCalls_.Size();) { DelayedMethodCall& call = delayedMethodCalls_[i]; bool remove = false; call.delay_ -= timeStep; if (call.delay_ <= 0.0f) { if (!call.repeat_) remove = true; else call.delay_ += call.period_; Execute(call.declaration_, call.parameters_); } if (remove) delayedMethodCalls_.Erase(i); else ++i; } // Execute delayed start before first update if (methods_[METHOD_DELAYEDSTART]) { scriptFile_->Execute(scriptObject_, methods_[METHOD_DELAYEDSTART]); methods_[METHOD_DELAYEDSTART] = 0; // Only execute once } if (methods_[METHOD_UPDATE]) { VariantVector parameters; parameters.Push(timeStep); scriptFile_->Execute(scriptObject_, methods_[METHOD_UPDATE], parameters); } }
void ParticleEmitter::SetParticlesAttr(const VariantVector& value) { unsigned index = 0; SetNumParticles(index < value.size() ? value[index++].GetUInt() : 0); for (auto i = particles_.begin(); i != particles_.end() && index < value.size(); ++i) { i->velocity_ = value[index++].GetVector3(); i->size_ = value[index++].GetVector2(); i->timer_ = value[index++].GetFloat(); i->timeToLive_ = value[index++].GetFloat(); i->scale_ = value[index++].GetFloat(); i->rotationSpeed_ = value[index++].GetFloat(); i->colorIndex_ = (unsigned)value[index++].GetInt(); i->texIndex_ = (unsigned)value[index++].GetInt(); } }
VariantVector ConnectionSettings::getChildren(ConnectionSettings *parent) { VariantVector vector; // Get children auto children = SmartObject::getChildren(); for (auto it = children.begin(); it != children.end(); ++it) { auto child = static_cast<ConnectionSettings *>(*it); // Add to collection vector.push_back(child->toVariantMap()); } return vector; }
VariantVector CrowdManager::GetQueryFilterTypesAttr() const { VariantVector ret; if (crowd_) { unsigned totalNumAreas = 0; for (unsigned i = 0; i < numQueryFilterTypes_; ++i) totalNumAreas += numAreas_[i]; ret.Reserve(numQueryFilterTypes_ * 3 + totalNumAreas + 1); ret.Push(numQueryFilterTypes_); for (unsigned i = 0; i < numQueryFilterTypes_; ++i) { const dtQueryFilter* filter = crowd_->getFilter(i); assert(filter); ret.Push(filter->getIncludeFlags()); ret.Push(filter->getExcludeFlags()); ret.Push(numAreas_[i]); for (unsigned j = 0; j < numAreas_[i]; ++j) ret.Push(filter->getAreaCost(j)); } } else ret.Push(0); return ret; }