BGE patch: DUPLIGROUP option supported in BGE.
authorBenoit Bolsee <benoit.bolsee@online.be>
Tue, 15 Jul 2008 20:05:23 +0000 (20:05 +0000)
committerBenoit Bolsee <benoit.bolsee@online.be>
Tue, 15 Jul 2008 20:05:23 +0000 (20:05 +0000)
Blender duplicates groups in the 3D view at the location of objects having the DUPLIGROUP option set. This feature is now supported in the BGE: the groups will be instantiated as in the 3D view when the scene is converted. This is useful to populate a scene with multiple enemies without having to actually duplicate the objects in the blend file.

Notes: * The BGE applies the same criteria to instantiate the group as Blender to display them: if you see the group in the 3D view, it will be instantiated in the BGE.
       * Groups are instantiated as if the object having the DUPLIGROUP option (usually an empty) executed an AddObject actuator on the top objects of the group (objects without parent).
       * As a result, only intra-group parent relationship is supported: the BGE will not instantiate objects that have parents outside the group.
       * Intra-group logic bricks connections are preserved between the duplicated objects, even between the top objects of the group.
       * For best result, the state engine of the objects in the group should be self-contained: logic bricks should only have intra-group connections. Use messages to communicate with state engines outside the group.
       * Nested groups are supported: if one or more objects in the group have the DUPLIGROUP option set, the corresponding groups will be instantiated at the corresponding position and orientation.
       * Nested groups are instantiated as separate groups, not as one big group.
       * Linked groups are supported as well as groups containing objects from the active layers.
       * There is a difference in the way Blender displays the groups in the 3D view and how BGE instantiates them: Blender does not take into account the parent relationship in the group and displays the objects as if they were all children of the object having the DUPLIGROUP option. That's correct for the top objects of the group but not for the children. Hence the orientation of the children objects may be different in the BGE.
       * An AddGroup actuator will be added in a future release.

source/gameengine/Converter/BL_BlenderDataConversion.cpp
source/gameengine/Ketsji/KX_GameObject.h
source/gameengine/Ketsji/KX_RadarSensor.cpp
source/gameengine/Ketsji/KX_Scene.cpp
source/gameengine/Ketsji/KX_Scene.h

index f3e22cd297a0a6eaedad6791dde51a479bc4ed17..1f1ac6da1193bbfa8b60c93807ad3a1defe41c46 100644 (file)
@@ -1847,7 +1847,10 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
        int aspect_width;
        int aspect_height;
        vector<MT_Vector3> inivel,iniang;
-       
+       set<Group*> grouplist;  // list of groups to be converted
+       set<Object*> allblobj;  // all objects converted
+       set<Object*> groupobj;  // objects from groups (never in active layer)
+
        if (alwaysUseExpandFraming) {
                frame_type = RAS_FrameSettings::e_frame_extend;
                aspect_width = canvas->GetWidth();
@@ -1919,6 +1922,8 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
        for (SETLOOPER(blenderscene, base))
        {
                Object* blenderobject = base->object;
+               allblobj.insert(blenderobject);
+
                KX_GameObject* gameobj = gameobject_from_blenderobject(
                                                                                base->object, 
                                                                                kxscene, 
@@ -2046,7 +2051,9 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
                                
                                gameobj->NodeUpdateGS(0,true);
                                gameobj->Bucketize();
-                               
+               
+                               if (gameobj->IsDupliGroup())
+                                       grouplist.insert(blenderobject->dup_group);
                        }
                        else
                        {
@@ -2073,6 +2080,188 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 
        }
 
+       if (!grouplist.empty())
+       {
+               // now convert the group referenced by dupli group object
+               // keep track of all groups already converted
+               set<Group*> allgrouplist = grouplist;
+               set<Group*> tempglist;
+               // recurse
+               while (!grouplist.empty())
+               {
+                       set<Group*>::iterator git;
+                       tempglist.clear();
+                       tempglist.swap(grouplist);
+                       for (git=tempglist.begin(); git!=tempglist.end(); git++)
+                       {
+                               Group* group = *git;
+                               GroupObject* go;
+                               for(go=(GroupObject*)group->gobject.first; go; go=(GroupObject*)go->next) 
+                               {
+                                       Object* blenderobject = go->ob;
+                                       if (converter->FindGameObject(blenderobject) == NULL)
+                                       {
+                                               allblobj.insert(blenderobject);
+                                               groupobj.insert(blenderobject);
+                                               KX_GameObject* gameobj = gameobject_from_blenderobject(
+                                                                                                               blenderobject, 
+                                                                                                               kxscene, 
+                                                                                                               rendertools, 
+                                                                                                               converter,
+                                                                                                               blenderscene);
+                                                                               
+                                               // this code is copied from above except that
+                                               // object from groups are never is active layer
+                                               bool isInActiveLayer = false;
+                                               bool addobj=true;
+                                               
+                                               if (converter->addInitFromFrame)
+                                                       if (!isInActiveLayer)
+                                                               addobj=false;
+                                                                                                               
+                                               if (gameobj&&addobj)
+                                               {
+                                                       MT_Point3 posPrev;                      
+                                                       MT_Matrix3x3 angor;                     
+                                                       if (converter->addInitFromFrame) 
+                                                               blenderscene->r.cfra=blenderscene->r.sfra;
+                                                       
+                                                       MT_Point3 pos = MT_Point3(
+                                                               blenderobject->loc[0]+blenderobject->dloc[0],
+                                                               blenderobject->loc[1]+blenderobject->dloc[1],
+                                                               blenderobject->loc[2]+blenderobject->dloc[2]
+                                                       );
+                                                       MT_Vector3 eulxyz = MT_Vector3(
+                                                               blenderobject->rot[0],
+                                                               blenderobject->rot[1],
+                                                               blenderobject->rot[2]
+                                                       );
+                                                       MT_Vector3 scale = MT_Vector3(
+                                                               blenderobject->size[0],
+                                                               blenderobject->size[1],
+                                                               blenderobject->size[2]
+                                                       );
+                                                       if (converter->addInitFromFrame){//rcruiz
+                                                               float eulxyzPrev[3];
+                                                               blenderscene->r.cfra=blenderscene->r.sfra-1;
+                                                               update_for_newframe();
+                                                               MT_Vector3 tmp=pos-MT_Point3(blenderobject->loc[0]+blenderobject->dloc[0],
+                                                                                                                       blenderobject->loc[1]+blenderobject->dloc[1],
+                                                                                                                       blenderobject->loc[2]+blenderobject->dloc[2]
+                                                                                                       );
+                                                               eulxyzPrev[0]=blenderobject->rot[0];
+                                                               eulxyzPrev[1]=blenderobject->rot[1];
+                                                               eulxyzPrev[2]=blenderobject->rot[2];
+
+                                                               double fps = (double) blenderscene->r.frs_sec/
+                                                                       (double) blenderscene->r.frs_sec_base;
+
+                                                               tmp.scale(fps, fps, fps);
+                                                               inivel.push_back(tmp);
+                                                               tmp=eulxyz-eulxyzPrev;
+                                                               tmp.scale(fps, fps, fps);
+                                                               iniang.push_back(tmp);
+                                                               blenderscene->r.cfra=blenderscene->r.sfra;
+                                                               update_for_newframe();
+                                                       }               
+                                                                               
+                                                       gameobj->NodeSetLocalPosition(pos);
+                                                       gameobj->NodeSetLocalOrientation(MT_Matrix3x3(eulxyz));
+                                                       gameobj->NodeSetLocalScale(scale);
+                                                       gameobj->NodeUpdateGS(0,true);
+                                                       
+                                                       BL_ConvertIpos(blenderobject,gameobj,converter);
+                                                       // TODO: expand to multiple ipos per mesh
+                                                       Material *mat = give_current_material(blenderobject, 1);
+                                                       if(mat) BL_ConvertMaterialIpos(mat, gameobj, converter);        
+                                       
+                                                       sumolist->Add(gameobj->AddRef());
+                                                       
+                                                       BL_ConvertProperties(blenderobject,gameobj,timemgr,kxscene,isInActiveLayer);
+                                                       
+                                       
+                                                       gameobj->SetName(blenderobject->id.name);
+                                       
+                                                       // templist to find Root Parents (object with no parents)
+                                                       templist->Add(gameobj->AddRef());
+                                                       
+                                                       // update children/parent hierarchy
+                                                       if ((blenderobject->parent != 0)&&(!converter->addInitFromFrame))
+                                                       {
+                                                               // blender has an additional 'parentinverse' offset in each object
+                                                               SG_Node* parentinversenode = new SG_Node(NULL,NULL,SG_Callbacks());
+                                                       
+                                                               // define a normal parent relationship for this node.
+                                                               KX_NormalParentRelation * parent_relation = KX_NormalParentRelation::New();
+                                                               parentinversenode->SetParentRelation(parent_relation);
+                                       
+                                                               parentChildLink pclink;
+                                                               pclink.m_blenderchild = blenderobject;
+                                                               pclink.m_gamechildnode = parentinversenode;
+                                                               vec_parent_child.push_back(pclink);
+
+                                                               float* fl = (float*) blenderobject->parentinv;
+                                                               MT_Transform parinvtrans(fl);
+                                                               parentinversenode->SetLocalPosition(parinvtrans.getOrigin());
+                                                               parentinversenode->SetLocalOrientation(parinvtrans.getBasis());
+                                                               
+                                                               parentinversenode->AddChild(gameobj->GetSGNode());
+                                                       }
+                                                       
+                                                       // needed for python scripting
+                                                       logicmgr->RegisterGameObjectName(gameobj->GetName(),gameobj);
+
+                                                       // needed for dynamic object morphing
+                                                       logicmgr->RegisterGameObj(gameobj, blenderobject);
+                                                       for (int i = 0; i < gameobj->GetMeshCount(); i++)
+                                                               logicmgr->RegisterGameMeshName(gameobj->GetMesh(i)->GetName(), blenderobject);
+                                       
+                                                       converter->RegisterGameObject(gameobj, blenderobject);  
+                                                       // this was put in rapidly, needs to be looked at more closely
+                                                       // only draw/use objects in active 'blender' layers
+                                       
+                                                       logicbrick_conversionlist->Add(gameobj->AddRef());
+                                                       
+                                                       if (converter->addInitFromFrame){
+                                                               posPrev=gameobj->NodeGetWorldPosition();
+                                                               angor=gameobj->NodeGetWorldOrientation();
+                                                       }
+                                                       if (isInActiveLayer)
+                                                       {
+                                                               objectlist->Add(gameobj->AddRef());
+                                                               //tf.Add(gameobj->GetSGNode());
+                                                               
+                                                               gameobj->NodeUpdateGS(0,true);
+                                                               gameobj->Bucketize();
+                                               
+                                                       }
+                                                       else
+                                                       {
+                                                               //we must store this object otherwise it will be deleted 
+                                                               //at the end of this function if it is not a root object
+                                                               inactivelist->Add(gameobj->AddRef());
+
+                                                       }
+                                                       if (gameobj->IsDupliGroup())
+                                                       {
+                                                               // check that the group is not already converted
+                                                               if (allgrouplist.insert(blenderobject->dup_group).second)
+                                                                       grouplist.insert(blenderobject->dup_group);
+                                                       }
+                                                       if (converter->addInitFromFrame){
+                                                               gameobj->NodeSetLocalPosition(posPrev);
+                                                               gameobj->NodeSetLocalOrientation(angor);
+                                                       }
+                                                                               
+                                               }
+                                               if (gameobj)
+                                                       gameobj->Release();
+                                       }
+                               }
+                       }
+               }
+       }
+
        if (blenderscene->camera) {
                KX_Camera *gamecamera= (KX_Camera*) converter->FindGameObject(blenderscene->camera);
                
@@ -2081,15 +2270,18 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
        }
 
        //      Set up armatures
-       for(SETLOOPER(blenderscene, base)){
-               if (base->object->type==OB_MESH){
-                       Mesh *me = (Mesh*)base->object->data;
+       set<Object*>::iterator oit;
+       for(oit=allblobj.begin(); oit!=allblobj.end(); oit++)
+       {
+               Object* blenderobj = *oit;
+               if (blenderobj->type==OB_MESH){
+                       Mesh *me = (Mesh*)blenderobj->data;
        
                        if (me->dvert){
-                               KX_GameObject *obj = converter->FindGameObject(base->object);
+                               KX_GameObject *obj = converter->FindGameObject(blenderobj);
        
-                               if (base->object->parent && base->object->parent->type==OB_ARMATURE && base->object->partype==PARSKEL){
-                                       KX_GameObject *par = converter->FindGameObject(base->object->parent);
+                               if (obj && blenderobj->parent && blenderobj->parent->type==OB_ARMATURE && blenderobj->partype==PARSKEL){
+                                       KX_GameObject *par = converter->FindGameObject(blenderobj->parent);
                                        if (par)
                                                ((BL_SkinDeformer*)(((BL_DeformableGameObject*)obj)->m_pDeformer))->SetArmature((BL_ArmatureObject*) par);
                                }
@@ -2174,7 +2366,8 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
                {
                        meshobj = gameobj->GetMesh(0);
                }
-               BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,activeLayerBitInfo,physics_engine,converter,processCompoundChildren);
+               int layerMask = (groupobj.find(blenderobject) == groupobj.end()) ? activeLayerBitInfo : 0;
+               BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,layerMask,physics_engine,converter,processCompoundChildren);
        }
 
        processCompoundChildren = true;
@@ -2189,7 +2382,8 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
                {
                        meshobj = gameobj->GetMesh(0);
                }
-               BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,activeLayerBitInfo,physics_engine,converter,processCompoundChildren);
+               int layerMask = (groupobj.find(blenderobject) == groupobj.end()) ? activeLayerBitInfo : 0;
+               BL_CreatePhysicsObjectNew(gameobj,blenderobject,meshobj,kxscene,layerMask,physics_engine,converter,processCompoundChildren);
        }
        
        
@@ -2311,22 +2505,25 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
        {
                KX_GameObject* gameobj = static_cast<KX_GameObject*>(logicbrick_conversionlist->GetValue(i));
                struct Object* blenderobj = converter->FindBlenderObject(gameobj);
-               bool isInActiveLayer = (blenderobj->lay & activeLayerBitInfo)!=0;
-               BL_ConvertActuators(maggie->name, blenderobj,gameobj,logicmgr,kxscene,ketsjiEngine,executePriority, activeLayerBitInfo,isInActiveLayer,rendertools,converter);
+               int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0;
+               bool isInActiveLayer = (blenderobj->lay & layerMask)!=0;
+               BL_ConvertActuators(maggie->name, blenderobj,gameobj,logicmgr,kxscene,ketsjiEngine,executePriority, layerMask,isInActiveLayer,rendertools,converter);
        }
        for ( i=0;i<logicbrick_conversionlist->GetCount();i++)
        {
                KX_GameObject* gameobj = static_cast<KX_GameObject*>(logicbrick_conversionlist->GetValue(i));
                struct Object* blenderobj = converter->FindBlenderObject(gameobj);
-               bool isInActiveLayer = (blenderobj->lay & activeLayerBitInfo)!=0;
-               BL_ConvertControllers(blenderobj,gameobj,logicmgr,pythondictionary,executePriority,activeLayerBitInfo,isInActiveLayer,converter);
+               int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0;
+               bool isInActiveLayer = (blenderobj->lay & layerMask)!=0;
+               BL_ConvertControllers(blenderobj,gameobj,logicmgr,pythondictionary,executePriority,layerMask,isInActiveLayer,converter);
        }
        for ( i=0;i<logicbrick_conversionlist->GetCount();i++)
        {
                KX_GameObject* gameobj = static_cast<KX_GameObject*>(logicbrick_conversionlist->GetValue(i));
                struct Object* blenderobj = converter->FindBlenderObject(gameobj);
-               bool isInActiveLayer = (blenderobj->lay & activeLayerBitInfo)!=0;
-               BL_ConvertSensors(blenderobj,gameobj,logicmgr,kxscene,keydev,executePriority,activeLayerBitInfo,isInActiveLayer,canvas,converter);
+               int layerMask = (groupobj.find(blenderobj) == groupobj.end()) ? activeLayerBitInfo : 0;
+               bool isInActiveLayer = (blenderobj->lay & layerMask)!=0;
+               BL_ConvertSensors(blenderobj,gameobj,logicmgr,kxscene,keydev,executePriority,layerMask,isInActiveLayer,canvas,converter);
        }
        // apply the initial state to controllers
        for ( i=0;i<logicbrick_conversionlist->GetCount();i++)
@@ -2344,5 +2541,19 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
        // Calculate the scene btree -
        // too slow - commented out.
        //kxscene->SetNodeTree(tf.MakeTree());
+
+       // instantiate dupli group, we will loop trough the object
+       // that are in active layers. Note that duplicating group
+       // has the effect of adding objects at the end of objectlist.
+       // Only loop through the first part of the list.
+       int objcount = objectlist->GetCount();
+       for (i=0;i<objcount;i++)
+       {
+               KX_GameObject* gameobj = (KX_GameObject*) objectlist->GetValue(i);
+               if (gameobj->IsDupliGroup())
+               {
+                       kxscene->DupliGroupRecurse(gameobj, 0);
+               }
+       }
 }
 
index ddbf863aa1afe960051178ad43f64bd2f3119380..eba154e10949d67cb3d9fd2b1f7aeec6fff01f83 100644 (file)
@@ -47,6 +47,7 @@
 #include "KX_Scene.h"
 #include "KX_KetsjiEngine.h" /* for m_anim_framerate */
 #include "KX_IPhysicsController.h" /* for suspend/resume */
+#include "DNA_object_types.h"
 #define KX_OB_DYNAMIC 1
 
 
@@ -392,6 +393,13 @@ public:
                m_pBlenderObject = obj;
        }
        
+       bool IsDupliGroup()
+       { 
+               return (m_pBlenderObject &&
+                               (m_pBlenderObject->transflag & OB_DUPLIGROUP) &&
+                               m_pBlenderObject->dup_group != NULL) ? true : false;
+       }
+
        /**
         * Set the Scene graph node for this game object.
         * warning - it is your responsibility to make sure
index 9dab09f8f2af990f190abeae756f54fb9f47cbab..bf2ba18f4905adf6979ddd386421ff1d889585dc 100644 (file)
@@ -80,10 +80,7 @@ CValue* KX_RadarSensor::GetReplica()
 {
        KX_RadarSensor* replica = new KX_RadarSensor(*this);
        replica->m_colliders = new CListValue();
-       replica->m_bCollision = false;
-       replica->m_bTriggered= false;
-       replica->m_hitObject = NULL;
-       replica->m_bLastTriggered = false;
+       replica->Init();
        // this will copy properties and so on...
        CValue::AddDataToReplica(replica);
        
index 065800379d860a743aa647d548f27a663e806d01..560333bd5cb2b927e45a1351d79be0d9f2469d66 100644 (file)
@@ -66,6 +66,8 @@
 #include "SG_Controller.h"
 #include "SG_IObject.h"
 #include "SG_Tree.h"
+#include "DNA_group_types.h"
+#include "BKE_anim.h"
 
 #include "KX_SG_NodeRelationships.h"
 
@@ -605,6 +607,128 @@ void KX_Scene::ReplicateLogic(KX_GameObject* newobj)
        newobj->ResetState();
 }
 
+void KX_Scene::DupliGroupRecurse(CValue* obj, int level)
+{
+       KX_GameObject* groupobj = (KX_GameObject*) obj;
+       KX_GameObject* replica;
+       Object* blgroupobj = groupobj->GetBlenderObject();
+       Group* group;
+       GroupObject *go;
+       vector<KX_GameObject*> duplilist;
+
+       if (!groupobj->IsDupliGroup() ||
+               level>MAX_DUPLI_RECUR)
+               return;
+
+       // we will add one group at a time
+       m_logicHierarchicalGameObjects.clear();
+       m_map_gameobject_to_replica.clear();
+       m_ueberExecutionPriority++;
+
+       group = blgroupobj->dup_group;
+       for(go=(GroupObject*)group->gobject.first; go; go=(GroupObject*)go->next) 
+       {
+               Object* blenderobj = go->ob;
+               if (blgroupobj == blenderobj)
+                       // this check is also in group_duplilist()
+                       continue;
+               KX_GameObject* gameobj = m_sceneConverter->FindGameObject(blenderobj);
+               if (gameobj == NULL) 
+               {
+                       // this object has not been converted!!!
+                       // Should not happen as dupli group are created automatically 
+                       continue;
+               }
+               if (gameobj->GetParent() != NULL)
+               {
+                       // this object is not a top parent. Either it is the child of another
+                       // object in the group and it will be added automatically when the parent
+                       // is added. Or it is the child of an object outside the group and the group
+                       // is inconsistent, skip it anyway
+                       continue;
+               }
+               if (blenderobj->lay & group->layer==0)
+               {
+                       // object is not visible in the 3D view, will not be instantiated
+                       continue;
+               }
+               replica = (KX_GameObject*) AddNodeReplicaObject(NULL,gameobj);
+               // add to 'rootparent' list (this is the list of top hierarchy objects, updated each frame)
+               m_parentlist->Add(replica->AddRef());
+
+               // recurse replication into children nodes
+               NodeList& children = gameobj->GetSGNode()->GetSGChildren();
+
+               replica->GetSGNode()->ClearSGChildren();
+               for (NodeList::iterator childit = children.begin();!(childit==children.end());++childit)
+               {
+                       SG_Node* orgnode = (*childit);
+                       SG_Node* childreplicanode = orgnode->GetSGReplica();
+                       replica->GetSGNode()->AddChild(childreplicanode);
+               }
+               // don't replicate logic now: we assume that the objects in the group can have
+               // logic relationship, even outside parent relationship
+
+               MT_Point3 newpos = groupobj->NodeGetWorldPosition();
+               replica->NodeSetLocalPosition(newpos);
+
+               MT_Matrix3x3 newori = groupobj->NodeGetWorldOrientation();
+               replica->NodeSetLocalOrientation(newori);
+       
+               // get the rootnode's scale
+               MT_Vector3 newscale = groupobj->GetSGNode()->GetRootSGParent()->GetLocalScale();
+
+               // set the replica's relative scale with the rootnode's scale
+               replica->NodeSetRelativeScale(newscale);
+
+               if (replica->GetPhysicsController())
+               {
+                       replica->GetPhysicsController()->setPosition(newpos);
+                       replica->GetPhysicsController()->setOrientation(newori.getRotation());
+                       replica->GetPhysicsController()->setScaling(newscale);
+               }
+
+               replica->GetSGNode()->UpdateWorldData(0);
+               replica->GetSGNode()->SetBBox(gameobj->GetSGNode()->BBox());
+               replica->GetSGNode()->SetRadius(gameobj->GetSGNode()->Radius());
+               // done with replica
+               replica->Release();
+       }
+
+       //      relink any pointers as necessary, sort of a temporary solution
+       vector<KX_GameObject*>::iterator git;
+       for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+       {
+               (*git)->Relink(&m_map_gameobject_to_replica);
+               // add the object in the layer of the parent
+               (*git)->SetLayer(groupobj->GetLayer());
+       }
+
+       // now replicate logic
+       for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+       {
+               (*git)->ReParentLogic();
+       }
+       
+       // replicate crosslinks etc. between logic bricks
+       for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+       {
+               ReplicateLogic((*git));
+       }
+       
+       // now look if object in the hierarchy have dupli group and recurse
+       for (git = m_logicHierarchicalGameObjects.begin();!(git==m_logicHierarchicalGameObjects.end());++git)
+       {
+               if ((*git) != groupobj && (*git)->IsDupliGroup())
+                       // can't instantiate group immediately as it destroys m_logicHierarchicalGameObjects
+                       duplilist.push_back((*git));
+       }
+
+       for (git = duplilist.begin(); !(git == duplilist.end()); ++git)
+       {
+               DupliGroupRecurse((*git), level+1);
+       }
+}
 
 
 SCA_IObject* KX_Scene::AddReplicaObject(class CValue* originalobject,
index 28dee1b589319c98a1c54614709b085206720956..374545f9a90079112206f1270e4f39f3863a194c 100644 (file)
@@ -291,6 +291,7 @@ public:
         * Update all transforms according to the scenegraph.
         */
        void UpdateParents(double curtime);
+       void DupliGroupRecurse(CValue* gameobj, int level);
        SCA_IObject* AddReplicaObject(CValue* gameobj,
                                                                  CValue* locationobj,
                                                                  int lifespan=0);