Handle<Value> SCROpenWindow(const Arguments& args) { osg::DisplaySettings* ds = osg::DisplaySettings::instance().get(); osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits(ds); traits->windowDecoration = true; traits->doubleBuffer = true; traits->sharedContext = 0; if(args.Length() > 1) { Handle<Object> traitsin = Handle<Object>::Cast(args[1]); if(traitsin->Has(String::New("x"))) traits->x = traitsin->Get(String::New("x"))->Int32Value(); if(traitsin->Has(String::New("y"))) traits->y = traitsin->Get(String::New("y"))->Int32Value(); if(traitsin->Has(String::New("width"))) traits->width = traitsin->Get(String::New("width"))->Int32Value(); if(traitsin->Has(String::New("height"))) traits->height = traitsin->Get(String::New("height"))->Int32Value(); if(traitsin->Has(String::New("windowDecoration"))) traits->windowDecoration = traitsin->Get(String::New("windowDecoration"))->BooleanValue(); if(traitsin->Has(String::New("hostName"))) traits->hostName = ToStdString(traitsin->Get(String::New("hostName"))); if(traitsin->Has(String::New("displayNum"))) traits->displayNum = traitsin->Get(String::New("displayNum"))->Int32Value(); if(traitsin->Has(String::New("screenNum"))) traits->screenNum = traitsin->Get(String::New("screenNum"))->Int32Value(); if(traitsin->Has(String::New("vsync"))) traits->vsync = traitsin->Get(String::New("vsync"))->BooleanValue(); } unsigned int contextid; // TODO how to pass traits??? //dtEntityOSG::OSGWindowInterface* wface = static_cast<dtEntityOSG::OSGWindowInterface*>(dtEntity::GetWindowInterface()); //wface->SetTraits(traits); bool success = dtEntity::GetWindowInterface()->OpenWindow(ToStdString(args[0]), contextid); assert(success); return Uint32::New(contextid); }
void TXmlStorage::AddNewElement(const UnicodeString & Name, const UnicodeString & Value) { std::string name = ToStdString(Name); std::string StrValue = ToStdString(Value); tinyxml2::XMLElement * Element = FXmlDoc->NewElement(name.c_str()); Element->LinkEndChild(FXmlDoc->NewText(StrValue.c_str())); FCurrentElement->LinkEndChild(Element); }
Handle<Value> MSAddEmptyMap(const Arguments& args) { if(args.Length() != 2) { return ThrowError("usage: addEmptyMap(datapath, mappath"); } dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); ms->AddEmptyMap(ToStdString(args[0]), ToStdString(args[1])); return Undefined(); }
Handle<Value> MSUnloadMap(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); bool success = ms->UnloadMap(ToStdString(args[0])); if(success) { return Undefined(); } else { return ThrowError("Could not unload map " + ToStdString(args[0])); } }
Handle<Value> MSSaveScene(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); bool success = ms->SaveScene(ToStdString(args[0]), args[1]->BooleanValue()); if(success) { return Undefined(); } else { return ThrowError("Could not save scene " + ToStdString(args[0])); } }
Handle<Value> MSGetSpawnerComponents(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); dtEntity::Spawner* spawner; if(!ms->GetSpawner(ToStdString(args[0]), spawner)) { return Null(); } HandleScope scope; Handle<Object> comps = Object::New(); dtEntity::Spawner::ComponentProperties props; spawner->GetAllComponentPropertiesRecursive(props); dtEntity::Spawner::ComponentProperties::iterator i; for(i = props.begin(); i != props.end(); ++i) { std::string compname = dtEntity::GetStringFromSID(i->first); Handle<Object> jscomp = Object::New(); const dtEntity::GroupProperty props = i->second; dtEntity::PropertyGroup g = props.Get(); for(dtEntity::PropertyGroup::const_iterator j = g.begin(); j != g.end(); ++j) { std::string propname = dtEntity::GetStringFromSID(j->first); const dtEntity::Property* prop = j->second; jscomp->Set(ToJSString(propname), ConvertPropertyToValue(args.This()->CreationContext(), prop)); } comps->Set(ToJSString(compname), jscomp); } return scope.Close(comps); }
bool TXmlStorage::DoOpenSubKey(const UnicodeString & MungedSubKey, bool CanCreate) { tinyxml2::XMLElement * OldCurrentElement = FCurrentElement; tinyxml2::XMLElement * Element = nullptr; std::string subKey = ToStdString(MungedSubKey); if (CanCreate) { if (FStoredSessionsOpened) { Element = FXmlDoc->NewElement(CONST_SESSION_NODE); Element->SetAttribute(CONST_NAME_ATTR, subKey.c_str()); } else { Element = FXmlDoc->NewElement(subKey.c_str()); } FCurrentElement->LinkEndChild(Element); } else { Element = FindChildElement(subKey); } bool Result = Element != nullptr; if (Result) { FSubElements.push_back(OldCurrentElement); FCurrentElement = Element; FStoredSessionsOpened = (MungedSubKey == FStoredSessionsSubKey); } return Result; }
bool TXmlStorage::DoKeyExists(const UnicodeString & SubKey, bool /*ForceAnsi*/) { UnicodeString K = PuttyMungeStr(SubKey); const tinyxml2::XMLElement * Element = FindChildElement(ToStdString(K)); bool Result = Element != nullptr; return Result; }
Handle<Value> MSSpawn(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); int eid = args[1]->Int32Value(); dtEntity::Entity* entity; bool success = ms->GetEntityManager().GetEntity(eid, entity); if(!success) { return ThrowError("Cannot spawn: not a valid entity! Usage: spawn(string spawner, entityid)"); } success = ms->Spawn(ToStdString(args[0]), *entity); if(!success) { return ThrowError("Cannot spawn: Spawner not found with name " + ToStdString(args[0])); } return True(); }
Application::TerminationFlag AppEntry(const Application& application) { std::cout << "Application Invoked" << std::endl; for (int i = 0; i < application.GetNumberOfCommandArguments(); i++) { std::cout << ToStdString(application.GetCommandArgument(i)) << std::endl; } return Application::NoReport; }
StatItem& GetStat(const PluginType& plug) { const void* const key = &plug; StatItem& res = Detection[key]; if (res.Name.empty()) { res.Name = ToStdString(plug.GetDescription()->Description()); res.Index = Detection.size() - 1; } return Detection[key]; }
// (?) std::string QHostAddress::toString() const { if (m_pImpl->getProtocol() == QAbstractSocket::IPv4Protocol) { quint32 ip = toIPv4Address(); return ToStdString(ip); } return std::string(); }
Handle<Value> ASIsAnimationPlaying(const Arguments& args) { dtEntity::AnimationSystem* ss = UnwrapAnimationSystem(args.This()); dtEntity::Component* acomp = ss->GetComponent(args[0]->Uint32Value()); if(acomp == NULL) { return False(); } dtEntity::AnimationComponent* animComp = static_cast<dtEntity::AnimationComponent*>(acomp); std::string animname = ToStdString(args[1]); return Boolean::New(animComp->IsAnimationPlaying(animname)); }
Handle<Value> ASClearAnimation(const Arguments& args) { dtEntity::AnimationSystem* ss = UnwrapAnimationSystem(args.This()); dtEntity::Component* acomp = ss->GetComponent(args[0]->Uint32Value()); if(acomp == NULL) { return ThrowError("Cannot clear animation: component with this entity id not found!"); } std::string animname = ToStdString(args[1]); static_cast<dtEntity::AnimationComponent*>(acomp)->ClearAnimation(animname, (float)args[2]->NumberValue()); return Undefined(); }
Handle<Value> MSAddToScene(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); bool success = ms->AddToScene(args[0]->Uint32Value()); if(success) { return Undefined(); } else { return ThrowError("Could not add to scene: " + ToStdString(args[0])); } }
Handle<Value> MSGetSpawner(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); dtEntity::Spawner* spawner; if(!ms->GetSpawner(ToStdString(args[0]), spawner)) { return Null(); } HandleScope scope; Handle<Object> obj = Object::New(); if(spawner->GetParent()) { obj->Set(String::New("parent"), String::New(spawner->GetParent()->GetName().c_str())); } else { obj->Set(String::New("parent"), String::New("")); } obj->Set(String::New("name"), String::New(spawner->GetName().c_str())); obj->Set(String::New("guicategory"), String::New(spawner->GetGUICategory().c_str())); obj->Set(String::New("mapname"), String::New(spawner->GetMapName().c_str())); obj->Set(String::New("addtospawnerstore"), Boolean::New(spawner->GetAddToSpawnerStore())); obj->Set(String::New("iconpath"), String::New(spawner->GetIconPath().c_str())); Handle<Object> comps = Object::New(); dtEntity::Spawner::ComponentProperties props; spawner->GetAllComponentProperties(props); dtEntity::Spawner::ComponentProperties::iterator i; for(i = props.begin(); i != props.end(); ++i) { std::string compname = dtEntity::GetStringFromSID(i->first); Handle<Object> jscomp = Object::New(); const dtEntity::GroupProperty props = i->second; dtEntity::PropertyGroup g = props.Get(); for(dtEntity::PropertyGroup::const_iterator j = g.begin(); j != g.end(); ++j) { std::string propname = dtEntity::GetStringFromSID(j->first); const dtEntity::Property* prop = j->second; jscomp->Set(ToJSString(propname), ConvertPropertyToValue(args.This()->CreationContext(), prop)); } comps->Set(ToJSString(compname), jscomp); } obj->Set(String::New("components"), comps); return scope.Close(obj); }
Handle<Value> MSGetEntitiesInMap(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); std::string mapname = ToStdString(args[0]); std::vector<dtEntity::EntityId> ids; ms->GetEntitiesInMap(mapname, ids); HandleScope scope; Handle<Array> arr = Array::New(); for(unsigned int i = 0; i < ids.size(); ++i) { arr->Set(Integer::New(i), Uint32::New(ids[i])); } return scope.Close(arr); }
Handle<Value> MSGetSpawnerCreatedEntities(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); std::string spawnername = ToStdString(args[0]); bool recursive = args[1]->BooleanValue(); std::vector<dtEntity::EntityId> ids; ms->GetSpawnerCreatedEntities(spawnername, ids, recursive); HandleScope scope; Handle<Array> arr = Array::New(); for(unsigned int i = 0; i < ids.size(); ++i) { arr->Set(i, Integer::New(ids[i])); } return scope.Close(arr); }
bool TXmlStorage::ReadXml() { CNBFile xmlFile; if (!xmlFile.OpenRead(GetStorage().c_str())) { return false; } size_t buffSize = static_cast<size_t>(xmlFile.GetFileSize() + 1); if (buffSize > 1000000) { return false; } std::string buff(buffSize, 0); if (!xmlFile.Read(&buff[0], buffSize)) { return false; } FXmlDoc->Parse(buff.c_str()); if (FXmlDoc->Error()) { return false; } // Get and check root node tinyxml2::XMLElement * xmlRoot = FXmlDoc->RootElement(); if (!xmlRoot) return false; const char * Value = xmlRoot->Value(); if (!Value) return false; if (strcmp(Value, CONST_ROOT_NODE) != 0) return false; const char * Attr = xmlRoot->Attribute(CONST_VERSION_ATTR); if (!Attr) return false; uintptr_t Version = ::StrToVersionNumber(UnicodeString(Attr)); if (Version < MAKEVERSIONNUMBER(2,0,0)) return false; tinyxml2::XMLElement * Element = xmlRoot->FirstChildElement(ToStdString(FStoredSessionsSubKey).c_str()); if (Element != nullptr) { FCurrentElement = FXmlDoc->RootElement(); return true; } return false; }
HRESULT __stdcall CDispatchWrapper::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pVarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr) { // we test if pVarResult is NULL because this is what VBA sets it to if the function is called as a statement (i.e. without // parentheses), but this then causes the arguments to be overwritten for some reason, so we pass it a dummy result // variable which we then dispose of VARIANT result; VariantInit(&result); HRESULT hRet = pDispatch->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult == NULL ? &result : pVarResult, pExcepInfo, puArgErr); VariantClear(&result); if(FAILED(hRet) && pExcepInfo->bstrDescription != NULL) { BSTR bstrOld = pExcepInfo->bstrDescription; std::string old; ToStdString(bstrOld, old); if(old.substr(0, 24) == "Unexpected Python Error:") { std::vector<std::string> parts; strsplit(old, "\n", parts, false); if(parts[0] == "Unexpected Python Error: Traceback (most recent call last):") { std::string neu; for(int k = (int) parts.size() - 1; k > 0; k--) { if(!parts[k].empty()) { if(!neu.empty()) neu += "\n"; neu += parts[k]; } } ToBStr(neu, pExcepInfo->bstrDescription); SysFreeString(bstrOld); } } } return hRet; }
void COPropertySetter(Local<String> propname, Local<Value> value, const AccessorInfo& info) { assert(!info.Holder().IsEmpty()); dtEntity::Component* component = UnwrapComponent(info.Holder()); if(component == NULL) { LOG_ERROR("Trying to access deleted component!"); return; } HandleScope scope; Handle<External> ext = Handle<External>::Cast(info.Data()); dtEntity::Property* prop = static_cast<dtEntity::Property*>(ext->Value()); assert(prop); SetPropertyFromValue(value, prop); #if CALL_ONPROPERTYCHANGED_METHOD component->OnPropertyChanged(dtEntity::SIDHash(ToStdString(propname)), *prop); #endif }
Handle<Value> ASPlayAnimation(const Arguments& args) { dtEntity::AnimationSystem* ss = UnwrapAnimationSystem(args.This()); dtEntity::Component* acomp = ss->GetComponent(args[0]->Uint32Value()); if(acomp == NULL) { return ThrowError("Cannot play animation: component with this entity id not found!"); } dtEntity::AnimationComponent* animComp = static_cast<dtEntity::AnimationComponent*>(acomp); std::string animname = ToStdString(args[1]); animComp->PlayAnimation(animname); // register callback to be executed when animation ends if(args.Length() >= 2 && args[2]->IsFunction()) { dtAnim::Animatable* anim = animComp->GetActiveAnimation(animname); assert(anim != NULL); s_animationEndCallbackHolder.AddAnimationEndCallback(anim, Handle<Function>::Cast(args[2])); } return Undefined(); }
Handle<Value> DebugDrawManagerAddString(const Arguments& args) { dtEntity::DebugDrawInterface* ddm = dtEntity::GetDebugDrawInterface(); if(!ddm->IsEnabled() ) { return Undefined(); } if(args.Length() < 2 || !IsVec3(args[0])) { return ThrowError("usage: addString(Vec3 position, text, Vec4 color, Number duration, bool useDepthTest])"); } dtEntity::Vec3f pos = UnwrapVec3(args[0]); std::string text = ToStdString(args[1]); dtEntity::Vec4f color(1,0,0,1); if(args.Length() > 2 && IsVec4(args[2])) { color = UnwrapVec4(args[2]); } float duration = 0; if(args.Length() > 3) { duration = args[3]->NumberValue(); } bool depth = true; if(args.Length() > 4) { depth = args[4]->BooleanValue(); } ddm->AddString(pos, text, color, duration, depth); return Undefined(); }
OGGStream(String file, bool _loop) { loop = _loop; finished = true; valid = false; std::string name = ToStdString(file); //cout << "Load OGG " << name << endl; //OGG file int error = 0; ogg = stb_vorbis_open_filename(&name[0], &error, NULL); if (!ogg) {cout << " VORBIS FAIL" << endl; return;} info = stb_vorbis_get_info(ogg); //Info output.channels = info.channels; output.rate = info.sample_rate; //Woot! valid = true; finished = false; }
boost::uuids::uuid GenerateUUIDFromString(const QString& qstring) { boost::uuids::string_generator gen; boost::uuids::uuid uuid = gen(ToStdString(qstring)); return uuid; }
Handle<Value> MSLoadMap(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); bool success = ms->LoadMap(ToStdString(args[0])); return Boolean::New(success); }
Handle<Value> MSIsSpawnOf(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); return Boolean::New(ms->IsSpawnOf(args[0]->Uint32Value(), ToStdString(args[1]))); }
Handle<Value> MSGetEntityIdByUniqueId(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); dtEntity::EntityId id = ms->GetEntityIdByUniqueId(ToStdString(args[0])); return Integer::New(id); }
Handle<Value> MSAddSpawner(const Arguments& args) { HandleScope scope; dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); if(args.Length() != 1) { return ThrowError("Usage: addSpawner({components, name, guicategory, mapname, addtospawnerstore, iconpath})"); } Handle<Object> obj = Handle<Object>::Cast(args[0]); Handle<Value> vname = obj->Get(String::New("name")); Handle<Value> vcomponents = obj->Get(String::New("components")); if(vname.IsEmpty() || vcomponents.IsEmpty()) { return ThrowError("Usage: addSpawner({components, name, guicategory, mapname, addtospawnerstore, iconpath, parentname})"); } Handle<Value> vguicategory = obj->Get(String::New("guicategory")); Handle<Value> vmapname = obj->Get(String::New("mapname")); Handle<Value> vaddtospawnerstore = obj->Get(String::New("addtospawnerstore")); Handle<Value> viconpath = obj->Get(String::New("iconpath")); Handle<Value> vparentname = obj->Get(String::New("parentname")); std::string name = ToStdString(vname); std::string mapname = vmapname.IsEmpty() ? "" : ToStdString(vmapname); Handle<Object> components = Handle<Object>::Cast(vcomponents); dtEntity::Spawner* parent = NULL; if(!vparentname.IsEmpty() && !vparentname->IsUndefined()) { ms->GetSpawner(ToStdString(vparentname), parent); } osg::ref_ptr<dtEntity::Spawner> spawner = new dtEntity::Spawner(name, mapname, parent); if(!vguicategory.IsEmpty() && !vguicategory->IsUndefined()) { spawner->SetGUICategory(ToStdString(vguicategory)); } if(!vaddtospawnerstore.IsEmpty() && !vaddtospawnerstore->IsUndefined()) { spawner->SetAddToSpawnerStore(vaddtospawnerstore->BooleanValue()); } if(!viconpath.IsEmpty() && !viconpath->IsUndefined()) { spawner->SetIconPath(ToStdString(viconpath)); } Handle<Array> keys = components->GetPropertyNames(); for(unsigned int i = 0; i < keys->Length(); ++i) { Handle<Value> key = keys->Get(Integer::New(i)); std::string keyname = ToStdString(key); dtEntity::StringId ctype = dtEntity::SIDHash(keyname); dtEntity::ComponentPluginManager::GetInstance().StartEntitySystem(ms->GetEntityManager(), ctype); if(ms->GetEntityManager().HasEntitySystem(ctype)) { Handle<Value> val = components->Get(key); if(val->IsObject()) { Handle<Object> compobj = Handle<Object>::Cast(val); Handle<Array> compkeys = compobj->GetPropertyNames(); dtEntity::GroupProperty props; for(unsigned int j = 0; j < compkeys->Length(); ++j) { Handle<Value> compkey = compkeys->Get(Integer::New(j)); std::string compkeystr = ToStdString(compkey); Handle<Value> compval = compobj->Get(compkey); dtEntity::Property* prop = ConvertValueToProperty(compval); props.Add(dtEntity::SIDHash(compkeystr), prop); } spawner->AddComponent(ctype, props); } } } ms->AddSpawner(*spawner); return Undefined(); }
Handle<Value> MSDeleteEntitiesByMap(const Arguments& args) { dtEntity::MapSystem* ms = UnwrapMapSystem(args.This()); ms->DeleteEntitiesByMap(ToStdString(args[0])); return Undefined(); }