// <T> -> <F> * <T> | <F> / <T> | <F>
APTNode* T(void)
{
APTNode* fNode = F();
APTNode* childTNode = NULL;
APTNode* opNode = NULL;
APTNode* parentTNode = createNonIdAPTNode("<T>");
addChildNode(parentTNode, fNode);
if (strcmp(currentTok.sym, "STARtk") == 0)
{
opNode = createNonIdAPTNode("<STARtk>");
addChildNode(parentTNode, opNode);
scanner();
childTNode = T();
addChildNode(parentTNode, childTNode);
} else if (strcmp(currentTok.sym, "SLASHtk") == 0)
{
opNode = createNonIdAPTNode("<SLASHtk>");
addChildNode(parentTNode, opNode);
scanner();
childTNode = T();
addChildNode(parentTNode, childTNode);
}
return parentTNode;
// T -> <F>
}
// <var> -> empty | <type> ID <mvars> ;
APTNode* VAR(void)
{
//HERE
if ((strcmp(currentTok.sym, "INTtk") == 0) || (strcmp(currentTok.sym, "FLOATtk") == 0)) {
//BUILD <TYPE> NODE
APTNode* typeNode = TYPE();
if (strcmp(currentTok.sym, "IDtk") == 0)
{
APTNode* idNode = createIdAPTNode("<IDtk>", currentTok.selection, NULL, currentTok.line);
scanner();
//BUILD <MVARS> NODE
APTNode* mvarsNode = MVARS();
if (strcmp(currentTok.sym, "SEMICOLtk") == 0)
{
scanner();
//BUILD <VAR> NODE
APTNode* varNode = createNonIdAPTNode("<VARtk>");
addChildNode(varNode, typeNode);
addChildNode(varNode, idNode);
addChildNode(varNode, mvarsNode);
return varNode;
} else errMsg("SEMICOLtk");
} else errMsg("IDtk");
} else return NULL;
}
// <mvars> -> empty | , ID <mvars>
APTNode* MVARS(void)
{
//HERE
if (strcmp(currentTok.sym, "COMMAtk") == 0)
{
scanner();
if (strcmp(currentTok.sym, "IDtk") == 0)
{
//BUILD <ID> NODE
APTNode* idNode = createIdAPTNode("<IDtk>", currentTok.selection, NULL, currentTok.line);
scanner();
//BUILD CHILD <MVARS> NODE
APTNode* childMvarsNode = MVARS();
//BUILD PARENT <MVARS> NODE
APTNode* parentMvarsNode = createNonIdAPTNode("<MVARS>");
addChildNode(parentMvarsNode, idNode);
addChildNode(parentMvarsNode, childMvarsNode);
return parentMvarsNode;
} else errMsg("IDtk");
} else return NULL; // MVARS -> empty
}
// <in> -> SCANF ID ;
APTNode* IN(void)
{
//HERE
if (strcmp(currentTok.sym, "SCANFtk") == 0)
{
APTNode* scanfNode = createNonIdAPTNode("<SCANFtk>");
scanner();
if (strcmp(currentTok.sym, "IDtk") == 0)
{
APTNode* idNode = createIdAPTNode("<IDtk>", currentTok.selection, NULL, currentTok.line);
scanner();
if (strcmp(currentTok.sym, "SEMICOLtk") == 0)
{
APTNode* inNode = createNonIdAPTNode("<INtk>");
addChildNode(inNode, scanfNode);
addChildNode(inNode, idNode);
scanner();
return inNode;
} else errMsg("SEMICOLtk");
} else errMsg("IDtk");
} else errMsg("SCANFtk");
}
// <assign> -> ID = <expr> ;
APTNode* ASSIGN()
{
//HERE
if (strcmp(currentTok.sym, "IDtk") == 0)
{
APTNode* idNode = createIdAPTNode("<IDtk>", currentTok.selection, NULL, currentTok.line);
scanner();
if (strcmp(currentTok.sym, "EQUALtk") == 0)
{
APTNode* eqNode = createNonIdAPTNode("<EQUALtk>");
scanner();
APTNode* exprNode = EXPR();
if (strcmp(currentTok.sym, "SEMICOLtk") == 0)
{
APTNode* assignNode = createNonIdAPTNode("<ASSIGNtk>");
addChildNode(assignNode, idNode);
addChildNode(assignNode, eqNode);
addChildNode(assignNode, exprNode);
scanner();
return assignNode;
} else errMsg("SEMICOLtk");
} else errMsg("EQUALtk");
} else errMsg("IDtk");
}
void Team::onInitialize()
{
// Setup state machine
mStateMachine = new StateMachine<Team>(this);
mStateMachine->setCurrentState(WaitingForKickOff::get());
// Initialize players
_createPlayers();
//Initialize regionID size
mAssignedRegionIDs.resize(mPlayers.size());
for (auto it = mPlayers.begin(); it != mPlayers.end(); ++it)
{
(*it)->getSteering()->setSeparationOn();
}
_findPlayerClosestToBall();
mPassSafePolygon.resize(mPitch->getPassSafePolygon().size());
// Add support spot calculator
mSupportSpotCalculator = (SupportSpotCalculator*)addChildNode(new SupportSpotCalculator("BestSupportSpotCalc", this)).get();
// Add GA
if(Prm.GASwitch)
{
mGAEnvironment = (Environment*)addChildNode(new Environment("GAEnvironment",this, mPitch)).get();
}
}
void SelectLevelState::onInitialize()
{
auto scene = addScene(new Scene("SelectLevel"));
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(0, 0, 10));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 0, 0));
//************************************************************
//The following lines are for test purpose only.
//Todo: Replace them with the actual content.
Ogre::FontManager::getSingleton().load("DejaVuSans", "General");
auto node1 = scene->addChildNode(new dt::Node("node1"));
auto text1 = node1->addComponent(new dt::TextComponent("Select Level", "text1"));
text1->setBackgroundMaterial("TextOverlayBackground");
text1->setColor(Ogre::ColourValue::White);
text1->setFont("DejaVuSans");
text1->setFontSize(72);
text1->setPadding(Ogre::Vector2(20, 20));
GuiRootWindow& rootWindow = GuiManager::get()->getRootWindow();
mReturnButton = rootWindow.addChildWidget<GuiButton>(new GuiButton("return"));
mReturnButton->setPosition(100, 100);
mReturnButton->setSize(250, 100);
mReturnButton->setCaption("Return");
dynamic_cast<MyGUI::Button*>(mReturnButton->getMyGUIWidget())->eventMouseButtonClick
+= MyGUI::newDelegate(this, &SelectLevelState::onReturnClick);
//************************************************************
}
// <loop> -> LOOP [ <expr> <RO> <expr> ] <block>
APTNode* LOOP(void)
{
if (strcmp(currentTok.sym, "LOOPtk") == 0)
{
scanner();
if (strcmp(currentTok.sym, "LBRACKtk") == 0)
{
scanner();
APTNode* lExprNode = EXPR();
APTNode* roNode = RO();
APTNode* rExprNode = EXPR();
if (strcmp(currentTok.sym, "RBRACKtk") == 0)
{
scanner();
APTNode* blockNode = BLOCK();
APTNode* loopNode = createNonIdAPTNode("<LOOPtk>");
addChildNode(loopNode, lExprNode);
addChildNode(loopNode, roNode);
addChildNode(loopNode, rExprNode);
addChildNode(loopNode, blockNode);
return loopNode;
} else errMsg("RBRACKtk");
} else errMsg("LBRACKtk");
} else errMsg("LOOPtk");
}
// <stats> -> <stat> <mStat>
APTNode* STATS(void)
{
APTNode* statsNode = createNonIdAPTNode("<STATStk>");
APTNode* statNode = STAT();
APTNode* mstatNode = MSTAT();
addChildNode(statsNode, statNode);
addChildNode(statsNode, mstatNode);
return statsNode;
}
ossimRefPtr<ossimXmlNode> ossimXmlNode::addNode(const ossimString& relPath,
const ossimString& text)
{
//
// Make a copy to manipulate:
//
ossimString relXpath (relPath);
if (relXpath.empty())
return 0;
//
// First verify that this is not an absolute path:
//
if (relXpath[static_cast<std::string::size_type>(0)] ==
XPATH_DELIM[static_cast<std::string::size_type>(0)])
{
ossimNotify(ossimNotifyLevel_WARN) << "WARNING: ossimXmlNode::findChildNodes\n"
<< "Only relative XPaths can be searched from a node. "
<< "Returning null list...\n";
return 0;
}
//
// Read the desired tag from the relative xpath
//
ossimString desiredTag (relXpath);
if (relXpath.contains(XPATH_DELIM))
{
desiredTag = relXpath.before(XPATH_DELIM);
}
ossimString subPath (relXpath.after(XPATH_DELIM));
ossimRefPtr<ossimXmlNode> node = findFirstNode(desiredTag);
if(!node.valid())
{
if(subPath.empty())
{
node = addChildNode(desiredTag, text);
}
else
{
node = addChildNode(desiredTag, "");
}
}
if(!subPath.empty())
{
return node->addNode(subPath, text);
}
return node;
}
void Main::onInitialize() {
auto scene = addScene(new dt::Scene("testscene"));
dt::ResourceManager::get()->addResourceLocation("sinbad.zip","Zip", true);
dt::ResourceManager::get()->addResourceLocation("particle/","FileSystem", true);
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
// make a scene
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(0, 2, 10));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 2, 0));;
auto p = scene->addChildNode(new dt::Node("p"));
p->setScale(0.2);
auto mesh = p->addComponent(new dt::MeshComponent("Sinbad.mesh"));
mesh->setAnimation("RunBase");
mesh->setLoopAnimation(true);
mesh->playAnimation();
auto path =
p->addComponent(new dt::FollowPathComponent(dt::FollowPathComponent::LOOP));
path->addPoint(Ogre::Vector3(-10, 0, 0));
path->addPoint(Ogre::Vector3(10, 0, 0));
path->setDuration(2.f);
path->setFollowRotation(true);
// create the particle system
auto p_sys = p->addComponent(new dt::ParticleSystemComponent("p_sys"));
p_sys->setMaterialName("Test/Particle");
p_sys->setParticleCountLimit(1000);
p_sys->getOgreParticleSystem()->setDefaultDimensions(0.03, 0.03);
Ogre::ParticleEmitter* e = p_sys->addEmitter("emit1", "Point");
e->setAngle(Ogre::Degree(10));
e->setColour(Ogre::ColourValue(1.f, 0.6f, 0.f), Ogre::ColourValue(0.2f, 0.8f, 0.2f));
e->setEmissionRate(100);
e->setParticleVelocity(3.f, 4.f);
e->setTimeToLive(1.f, 2.f);
p_sys->addScalerAffector("scaler", 1.05);
p_sys->addLinearForceAffector("force", Ogre::Vector3(0, 5, 0));
Ogre::ParticleAffector* a = p_sys->addAffector("colour_interpolator", "ColourInterpolator");
a->setParameter("time0", "0");
a->setParameter("colour0", "1 1 0 1");
a->setParameter("time1", "0.5");
a->setParameter("colour1", "1 0.3 0 1");
a->setParameter("time2", "1");
a->setParameter("colour2", "1 0 0 0");
}
ossimRefPtr<ossimXmlNode> ossimXmlNode::addNode(const ossimString& relPath,
const ossimString& text)
{
if (relPath.empty())
return 0;
//
// First verify that this is not an absolute path:
//
if (relPath[static_cast<std::string::size_type>(0)] == XPATH_DELIM)
{
if(traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN) << "WARNING: ossimXmlNode::addNode\n"
<< "Only relative XPaths can be searched from a node. "
<< "Returning null list...\n";
}
return 0;
}
//
// Read the desired tag from the relative xpath
//
const std::string::size_type delim_pos = relPath.find(XPATH_DELIM);
const ossimString desiredTag = relPath.substr(0,delim_pos);
ossimRefPtr<ossimXmlNode> node = findFirstNode(desiredTag);
if(!node.valid())
{
// No XPATH_DELIM character found, or XPATH_DELIM at the end of xpath
if (delim_pos==std::string::npos || delim_pos == relPath.size()-1)
{
node = addChildNode(desiredTag, text);
}
else
{
node = addChildNode(desiredTag, "");
}
}
if (delim_pos != std::string::npos && delim_pos != relPath.size()-1) // XPATH_DELIM character found!
{
const ossimString subPath = relPath.substr(delim_pos+1, std::string::npos);
return node->addNode(subPath, text);
}
return node;
}
//recursive
bool SeqTreeAsnizer::addChildNode(SeqTree& seqTree, SeqTreeIterator parentNode,
CSeqTree_node& asnNode, SeqLocToSeqItemMap& liMap)
{
SeqItem sItem;
fillSeqItem(asnNode, sItem);
SeqTreeIterator np = seqTree.append_child(parentNode, sItem);
if (asnNode.CanGetChildren())
{
if (asnNode.GetChildren().IsChildren())
{
list< CRef< CSeqTree_node > >& children = asnNode.SetChildren().SetChildren();
list< CRef< CSeqTree_node > >::iterator lcit = children.begin();
for(; lcit != children.end(); lcit++)
{
addChildNode(seqTree, np, **lcit, liMap);
}
}
else //it is Footprint Node
{
TreeNodePair tnp(np, &asnNode);
liMap.insert(SeqLocToSeqItemMap::value_type(
&(asnNode.GetChildren().GetFootprint().GetSeqRange()), tnp));
}
}
return true;
}
// <stat> -> <in> | <out> | <block> | <if> | <loop> | <assign>
APTNode* STAT(void)
{
//printf("STAT node with sym = %s and text = %s \n", currentTok.sym, currentTok.selection);
APTNode* parentStatNode = createNonIdAPTNode("<STATtk>");
APTNode* childNode;
if (strcmp(currentTok.sym, "SCANFtk") == 0)
{
childNode = IN();
} else if (strcmp(currentTok.sym, "PRINTFtk") == 0)
{
childNode = OUT();
} else if (strcmp(currentTok.sym, "IFtk") == 0)
{
childNode = IF();
} else if (strcmp(currentTok.sym, "LOOPtk") == 0)
{
childNode = LOOP();
} else if (strcmp(currentTok.sym, "IDtk") == 0)
{
childNode = ASSIGN();
} else if (strcmp(currentTok.sym, "BEGINtk") == 0)
{
childNode = BLOCK();
} else errMsg("STATEMENT tok");
addChildNode(parentStatNode, childNode);
return parentStatNode;
}
bool SeqTreeAsnizer::convertToSeqTree(CSequence_tree & asnSeqTree, SeqTree& seqTree, SeqLocToSeqItemMap& liMap)
{
if (!asnSeqTree.IsSetRoot())
return false;
CSeqTree_node& root = asnSeqTree.SetRoot();
//add the node self
SeqItem sItem;
fillSeqItem(root, sItem);
SeqTreeIterator rootIterator = seqTree.insert(seqTree.begin(), sItem);
//add its children
if (root.CanGetChildren())
{
if (root.GetChildren().IsChildren())
{
list< CRef< CSeqTree_node > >& children = root.SetChildren().SetChildren();
list< CRef< CSeqTree_node > >::iterator lcit = children.begin();
for(; lcit != children.end(); lcit++)
{
addChildNode(seqTree, rootIterator, **lcit, liMap);
}
}
else
return false;
}
else
return false;
return true;
}
int fmove(char *source, char *target)
{
//if ((ret = fexist(pathname))==-1)
int ret1, ret2;
int state1, state2;
uint8_t parent;
char *p, *q;
uint8_t namelength;
p = extractLastName(target);
q = target + strlen(target);
namelength = q-p ;
ret1 = locateFileName(source, &state1);
parent = read8uint(ret1, FILE_PARENTOFFSET);
removeChildNode(parent, ret1);
ret2 = locateFileName(target, &state2);
write8uint(ret1, FILE_PARENTOFFSET, ret2);
writeBytes(ret1, FILENAMEOFFSET, namelength, p);
write8uint(ret1, FILENAMEOFFSET+namelength, 0);
addChildNode(ret2, ret1);
return 0;
}
void
TextTrieMap::putImpl(const UnicodeString &key, void *value, UErrorCode &status) {
if (fNodes == NULL) {
fNodesCapacity = 512;
fNodes = (CharacterNode *)uprv_malloc(fNodesCapacity * sizeof(CharacterNode));
fNodes[0].clear(); // Init root node.
fNodesCount = 1;
}
UnicodeString foldedKey;
const UChar *keyBuffer;
int32_t keyLength;
if (fIgnoreCase) {
// Ok to use fastCopyFrom() because we discard the copy when we return.
foldedKey.fastCopyFrom(key).foldCase();
keyBuffer = foldedKey.getBuffer();
keyLength = foldedKey.length();
} else {
keyBuffer = key.getBuffer();
keyLength = key.length();
}
CharacterNode *node = fNodes;
int32_t index;
for (index = 0; index < keyLength; ++index) {
node = addChildNode(node, keyBuffer[index], status);
}
node->addValue(value, fValueDeleter, status);
}
size_t Entity::addActor(Actor* inActor)
{
assert(inActor != NULL);
mActors.push_back(inActor);
addChildNode(inActor);
return mActors.size() - 1;
}
// <mStat> -> empty | <stat> <mStat>
APTNode* MSTAT(void)
{
if ((strcmp(currentTok.sym, "SCANFtk") == 0) || (strcmp(currentTok.sym, "PRINTFtk") == 0) ||
(strcmp(currentTok.sym, "IFtk") == 0) || (strcmp(currentTok.sym, "LOOPtk") == 0) ||
(strcmp(currentTok.sym, "BEGINtk") == 0) || (strcmp(currentTok.sym, "IDtk") == 0))
{
//printf("MSTAT node with sym = %s and text = %s \n", currentTok.sym, currentTok.selection);
APTNode* parentMstatNode = createNonIdAPTNode("<MSTAT>");
APTNode* statNode = STAT();
APTNode* childMstatNode = MSTAT();
addChildNode(parentMstatNode, statNode);
addChildNode(parentMstatNode, childMstatNode);
return parentMstatNode;
} else return NULL;
}
void ossimXmlNode::addChildren(ossimXmlNode::ChildListType& children)
{
ossim_uint32 idx;
for(idx = 0; idx < children.size(); ++idx)
{
addChildNode(children[idx].get());
}
}
QgsLayerTreeLayer* QgsLayerTreeGroup::addLayer( QgsMapLayer* layer )
{
if ( !layer || QgsMapLayerRegistry::instance()->mapLayer( layer->id() ) != layer )
return nullptr;
QgsLayerTreeLayer* ll = new QgsLayerTreeLayer( layer );
addChildNode( ll );
return ll;
}
QgsLayerTreeLayer *QgsLayerTreeGroup::addLayer( QgsMapLayer *layer )
{
if ( !layer )
return nullptr;
QgsLayerTreeLayer *ll = new QgsLayerTreeLayer( layer );
addChildNode( ll );
return ll;
}
void Node::insertAfter(Node* n){
Node * temp;
for(int i = 0; i < n->children.size(); ++i){
temp = n->children[i];
n->removeChildNode(temp);
addChildNode(temp);
}
n->addChildNode(this);
}
int fcopy(char *source, char *target)
{
//if ((ret = fexist(pathname))==-1)
int ret1, ret2;
int state1, state2;
uint8_t i;
char *p;
char *q;
int NewNode;
uint8_t namelength;
p = extractLastName(target);
q = target + strlen(target);
namelength = q-p ;
ret1 = locateFileName(source, &state1);
ret2 = locateFileName(target, &state2);
NewNode = getVectorNode();
copyVectorNode(ret1, NewNode);
writeBytes(NewNode, FILENAMEOFFSET, namelength, p);
write8uint(NewNode, FILENAMEOFFSET+namelength, 0);
write8uint(NewNode, FILE_PARENTOFFSET, ret2);
addChildNode(ret2, NewNode);
for (i=0; i<8; i++)
{
uint8_t temp, temp1;
temp = read8uint(ret1, FILE_ADDRPAGEOFFSET+i);
if (temp >0)
{ temp1 = getFlashPage();
write8uint(NewNode, FILE_ADDRPAGEOFFSET+i, temp1);
copyVectorPage(temp, temp1);
}
}
return 0;
}
// <out> -> PRINTF <expr> ;
APTNode* OUT(void)
{
if (strcmp(currentTok.sym, "PRINTFtk") == 0)
{
APTNode* scanfNode = createNonIdAPTNode("<PRINTFtk>");
scanner();
APTNode* exprNode = EXPR();
if (strcmp(currentTok.sym, "SEMICOLtk") == 0)
{
APTNode* outNode = createNonIdAPTNode("<OUTtk>");
addChildNode(outNode, scanfNode);
addChildNode(outNode, exprNode);
scanner();
return outNode;
} else errMsg("SEMICOLtk");
} else errMsg("PRINTFtk");
}
// <F> -> - <F> | <R>
APTNode* F(void)
{
APTNode* parentFNode = createNonIdAPTNode("<F>");
if (strcmp(currentTok.sym, "MINUStk") == 0)
{
APTNode* minusNode = createNonIdAPTNode("<MINUStk>");
addChildNode(parentFNode, minusNode);
scanner();
APTNode* childFNode = F();
addChildNode(parentFNode, childFNode);
} else{
APTNode* rNode = R(); // F -> <R>
addChildNode(parentFNode, rNode);
}
return parentFNode;
}
void Main::onInitialize() {
auto scene = addScene(new dt::Scene("testscene"));
dt::ResourceManager::get()->addResourceLocation("","FileSystem");
dt::ResourceManager::get()->addResourceLocation("crate","FileSystem");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
OgreProcedural::Root::getInstance()->sceneManager = scene->getSceneManager();
OgreProcedural::SphereGenerator().setRadius(1.f).setUTile(.5f).realizeMesh("Sphere");
OgreProcedural::PlaneGenerator().setSizeX(100.f).setSizeY(100.f).setVTile(10.f).setUTile(10.f).realizeMesh("Plane");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
auto camnode = scene->addChildNode(new dt::Node("camnode"));
camnode->setPosition(Ogre::Vector3(30, 25, 30));
camnode->addComponent(new dt::CameraComponent("cam"))->lookAt(Ogre::Vector3(0, 10, 0));;
auto planenode = scene->addChildNode(new dt::Node("planenode"));
planenode->setPosition(Ogre::Vector3(0, 0, 0));
planenode->addComponent(new dt::MeshComponent("Plane", "PrimitivesTest/Pebbles", "plane-mesh"));
planenode->addComponent(new dt::PhysicsBodyComponent("plane-mesh", "plane-body",
dt::PhysicsBodyComponent::CONVEX, 0.0f));
auto lightnode1 = scene->addChildNode(new dt::Node("lightnode1"));
lightnode1->addComponent(new dt::LightComponent("light1"));
lightnode1->setPosition(Ogre::Vector3(15, 5, 15));
int n = 2; // (n*2+1) ^ 3 blocks
for(int x = -n; x <= n; ++x) {
for(int y = -n; y <= n; ++y) {
for(int i = 0; i < n*2 + 1; ++i) {
auto node = scene->addChildNode(new dt::Node("node"
"x-" + dt::Utils::toString(x) + "-" +
"y-" + dt::Utils::toString(y) + "-" +
"z-" + dt::Utils::toString(i) ));
node->setPosition(Ogre::Vector3(x * 2.5, i * 2.5 + 5, y * 2.5));
node->addComponent(new dt::MeshComponent("Crate01.mesh", "", "mesh"));
node->addComponent(new dt::PhysicsBodyComponent("mesh", "body"));
}
}
}
}
// <expr> -> <T> + <expr> | <T> - <expr> | <T>
APTNode* EXPR(void)
{
APTNode* tNode = T();
APTNode* parentExprNode = createNonIdAPTNode("<EXPR>");
addChildNode(parentExprNode, tNode);
if (strcmp(currentTok.sym, "PLUStk") == 0)
{
addChildNode(parentExprNode, createNonIdAPTNode("<PLUStk>"));
scanner();
addChildNode(parentExprNode, EXPR());
} else if (strcmp(currentTok.sym, "MINUStk") == 0)
{
addChildNode(parentExprNode, createNonIdAPTNode("<MINUStk>"));
scanner();
addChildNode(parentExprNode, EXPR());
}
return parentExprNode;
}
size_t Entity::addActor(Actor* inActor, size_t inIndex)
{
assert(inActor != NULL);
mActors.push_back(inActor);
if (inIndex < mActors.size())
mActors[inIndex]->addChildNode(inActor);
else
addChildNode(inActor);
return mActors.size() - 1;
}
void Node::serialize(IOPacket& packet) {
packet.stream(mId, "uuid");
packet.stream(mName, "name", mName);
packet.stream(mPosition, "position");
packet.stream(mScale, "scale", Ogre::Vector3::UNIT_SCALE);
packet.stream(mRotation, "rotation");
packet.stream(mIsEnabled, "enabled");
onSerialize(packet);
// Components
uint32_t count = packet.beginList(mComponents.size(), "components");
if(packet.getDirection() == IOPacket::SERIALIZE) {
// serialize
for(auto iter = mComponents.begin(); iter != mComponents.end(); ++iter) {
packet.beginObject();
iter->second->serialize(packet);
packet.endObject();
}
} else {
for(uint32_t i = 0; i < count; ++i) {
packet.beginObject();
std::string type;
packet.stream(type, "type", std::string(""));
Component* c = Serializer::createComponent(type);
c->serialize(packet);
addComponent(c);
packet.endObject();
}
}
packet.endList();
// Children
count = packet.beginList(mChildren.size(), "children");
if(packet.getDirection() == IOPacket::SERIALIZE) {
for(auto iter = mChildren.begin(); iter != mChildren.end(); ++iter) {
packet.beginObject();
iter->second->serialize(packet);
packet.endObject();
}
} else {
for(uint32_t i = 0; i < count; ++i) {
packet.beginObject();
Node* n = new Node;
n->serialize(packet);
addChildNode(n);
packet.endObject();
}
}
packet.endList();
}
