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