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