C++ DiCullNode类代码示例

    void DiK2World::Load(const DiString& path)
    {
        DI_LOG("Loading world: %s", path.c_str());

        DiK2WorldSerial serial;
        serial.Load(path,this);
        mRootNode->AttachObject(mTerrain);
        
        // sun light
        mSun = make_shared<DiDirLight>();
        DiSceneManager* sm = DiBase::Driver->GetSceneManager();
        DiCullNode* dirNode = sm->GetRootNode()->CreateChild();
        dirNode->AttachObject(mSun);
        mSun->SetColor(DiColor());
        
        DiRadian altitude(DiDegree(mConfigs.mSunAltitude));
        DiVec3 dir(0,-DiMath::Sin(altitude),DiMath::Cos(altitude));
        
        DiRadian azimuth(DiDegree(mConfigs.mSunAzimuth));
        DiQuat rot(azimuth, DiVec3::UNIT_Y);
        dir = rot * dir;
        mSun->SetDirection(dir);
        
        sm->SetAmbientColor(DiColor());
    
        Demi::DiRenderBatchGroup* group = Driver->GetPipeline()->GetBatchGroup(Demi::BATCH_MODEL);
        group->SetPreProcess([this](){
            Driver->GetPipeline()->GetShaderEnvironment()->globalAmbient = mConfigs.mEntityAmbient;
            Driver->GetPipeline()->GetShaderEnvironment()->dirLightsColor[0] = mConfigs.mEntitySunColor;
        });
    }

    void DiK2World::ProcessCliff(DiK2RenderObject* renderObj)
    {
        DiK2ModelPtr model = renderObj->GetModel();
        model->SetBatchGroup(BATCH_TERRAIN);
        DiCullNode* node = renderObj->GetNode();

        DiVec3 pos = node->GetPosition();
        DiQuat rot = node->GetOrientation();

        DiTerrainDescPtr terDesc = mTerrain->GetDesc();

        float cliffsize = terDesc->mCliffSize * terDesc->mGridSize / 2.0f;
        DiVec3 transl(-cliffsize, 0, cliffsize);
        pos += rot * transl;
       
        DiTerrainDescPtr desc = mTerrain->GetDesc();

        int gridx = pos.x / CHUNK_GRID_SIZE;
        int gridy = pos.z / CHUNK_GRID_SIZE;
        int gridSizeX = (CHUNK_GRID_SIZE * desc->mSizeX);
        int gridSizeY = (CHUNK_GRID_SIZE * desc->mSizeY);

        int realGrid = gridx + gridy * gridSizeX;
        realGrid = DiMath::Clamp(realGrid, 0, gridSizeX*gridSizeY - 1);
        
        uint16 diftexid = desc->mTextureIDMap->GetBuffer(0)[realGrid].diffuseID;
        uint16 normtexid = desc->mTextureIDMap->GetBuffer(0)[realGrid].normalID;

        DiString diffuse = desc->mTextureTable[diftexid];
        DiString normal = desc->mTextureTable[normtexid];

        DiTexturePtr textureDif = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(diffuse);
        
#if DEMI_PLATFORM == DEMI_PLATFORM_IOS
        DiTexturePtr textureNor = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(normal);
#else
        DiTexturePtr textureNor = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(normal + "_rxgb");
        DiTexturePtr textureSpe = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(normal + "_s");
#endif

        uint32 submodels = model->GetNumSubModels();
        for (uint32 i = 0; i < submodels; ++i)
        {
            DiSubModel* sm = model->GetSubModel(i);
            auto material = sm->GetMaterial();

            auto newMat = material->Clone();
            sm->SetMaterial(newMat);

            DiShaderParameter* shaderparam = newMat->GetShaderParameter();
            shaderparam->WriteTexture2D("terrainMap", textureDif);
            shaderparam->WriteTexture2D("terrainNormalMap", textureNor);
#if DEMI_PLATFORM != DEMI_PLATFORM_IOS
            shaderparam->WriteTexture2D("terrainSpecularMap", textureSpe);
#endif
            shaderparam->WriteFloat("cliffUVScale", 1.0f / (terDesc->mTextureScale * terDesc->mGridSize));
        }
    }

    DiNode* DiCullNode::CreateChild(const DiVec3& inTranslate, const DiQuat& inRotate)
    {
        DiCullNode* newNode = mCreator->CreateNode();
        newNode->Translate(inTranslate);
        newNode->Rotate(inRotate);
        this->AddChild(newNode);

        return newNode;
    }

 void DiCullNode::RemoveAllChildren( void )
 {
     for (size_t i = 0; i < mChildren.size(); ++i)
     {
         DiCullNode* on = static_cast<DiCullNode*>(mChildren[i]);
         on->SetParent(nullptr);
         on->RemoveNodeAndChildren();
     }
     mChildren.clear();
     mChildrenToUpdate.clear();
 }

void AddMeshes()
{
    DiSceneManager* sm = DiBase::Driver->GetSceneManager();

	DiCullNode* cullnode = sm->GetRootNode()->CreateChild();
	DiModelPtr model = make_shared<DiModel>("sponza_model","sponza.model");

	cullnode->AttachObject(model);
	cullnode->SetScale(6,6,6);

	//sm->GetCamera()->SetFarClipDistance(200);
}

    DiInstanceBatchPtr DiInstanceManager::BuildNewBatch(const DiString& materialName, bool firstTime)
    {
        DiSubMesh::IndexMap &idxMap = mMeshReference->GetSubMesh(mSubMeshIdx)->GetBlendIndexToBoneIndexMap();
        //idxMap = idxMap.empty() ? mMeshReference->sharedBlendIndexToBoneIndexMap : idxMap;

        DiMaterialPtr mat = DiAssetManager::GetInstance().GetAsset<DiMaterial>( materialName );

        InstanceBatchVec &materialInstanceBatch = mInstanceBatches[materialName];

        DiInstanceBatchPtr batch;

        DiString name;
        name.Format("%s_InstanceBatch_%d",mName.c_str(),mIdCount++);

        switch( mInstancingTechnique )
        {
        case INSTANCE_SHADER_BASED:
            batch = make_shared<DiInstanceBatchShader>( this, mMeshReference, mMotionReference, mat, mInstancesPerBatch,
                &idxMap, name );
            break;
        case INSTANCE_HARDWARE_BASED:
            batch = make_shared<DiInstanceBatchHardware>(this, mMeshReference, mat, mInstancesPerBatch,
                name );
            break;
        default:
            DI_ERROR("Unsupported instanced technique.");
            break;
        }

        if( !firstTime )
        {
            batch->BuildFrom( mMeshReference->GetSubMesh(mSubMeshIdx) );
        }
        else
        {
            const size_t maxInstPerBatch = batch->CalculateMaxNumInstances( mMeshReference->
                GetSubMesh(mSubMeshIdx) );
            mInstancesPerBatch = DiMath::Min( maxInstPerBatch, mInstancesPerBatch );
            batch->SetInstancesPerBatch( mInstancesPerBatch );

            batch->Build( mMeshReference->GetSubMesh(mSubMeshIdx) );
        }

        //const BatchSettings &batchSettings = mBatchSettings[materialName];
        //batch->SetCastShadows( batchSettings.setting[CAST_SHADOWS] );

        DiCullNode *sceneNode = mSceneManager->GetRootNode()->CreateChild();
        sceneNode->AttachObject( batch );

        materialInstanceBatch.push_back( batch );

        return batch;
    }

    void DiCullNode::FlipVisibility( bool cascade /*= true*/ )
    {
        for (auto oi = mObjects.begin(); oi != mObjects.end(); ++oi)
        {
            (*oi)->SetVisible(!(*oi)->GetVisible());
        }

        if (cascade)
        {
            for (size_t i = 0; i < mChildren.size(); ++i)
            {
                DiCullNode* sceneChild = static_cast<DiCullNode*>(mChildren[i]);
                sceneChild->FlipVisibility(cascade);
            }
        }
    }

    void DiCullNode::FlipVisibility( bool cascade /*= true*/ )
    {
        ObjectMap::iterator oi, oiend;
        oiend = mObjectsByName.end();
        for (oi = mObjectsByName.begin(); oi != oiend; ++oi)
        {
            oi->second->SetVisible(!oi->second->GetVisible());
        }

        if (cascade)
        {
            for (size_t i = 0; i < mChildren.size(); ++i)
            {
                DiCullNode* sceneChild = static_cast<DiCullNode*>(mChildren[i]);
                sceneChild->FlipVisibility(cascade);
            }
        }
    }

    DiInstanceBatch::~DiInstanceBatch()
    {
        DeleteAllInstancedModels();

        DiCullNode *sceneNode = GetParentCullNode();
        if( sceneNode )
        {
            sceneNode->DetachAllObjects();
            sceneNode->GetParent()->RemoveChild( sceneNode->GetName() );
        }

        if( mRemoveOwnVertexData )
            ReleaseSourceData();
        if( mRemoveOwnIndexData )
            ReleaseIndexBuffer();
        
        ReleaseVertexDeclaration();
    }

void InitScene()
{
    DiSceneManager* sm = DiBase::Driver->GetSceneManager();
    sm->SetAmbientColor(DiColor(0.6f, 0.6f, 0.6f));
    
    float scale = 0.5f;
    DiDirLightPtr dirlight;
    dirlight = make_shared<DiDirLight>();
    DiCullNode* dirNode = sm->GetRootNode()->CreateChild();
    dirNode->AttachObject(dirlight);
    dirlight->SetColor(DiColor(0.8f,0.8f,0.8f));
    dirlight->SetDirection(DiVec3(0.3f,-0.7f,0.4).normalisedCopy());
    //dirlight->InitForShadowCasting(sm, ShadowTextureConfig(1024,1024,PF_A32B32G32R32F));
    
    auto pos = DiVec3(150,275,130)*2;
    dirNode->SetPosition(pos);
    
    DiCullNode* spotNode = sm->GetRootNode()->CreateChild();
    DiSpotLightPtr sptLt = make_shared<DiSpotLight>();
    spotNode->AttachObject(sptLt);
    //spotNode->SetPosition(50, 100, 40);
    spotNode->SetPosition(pos);
    sptLt->SetDirection((-pos).normalisedCopy());
    sptLt->SetRange( DiDegree(80), DiDegree(90) );
    sptLt->InitForShadowCasting(sm, ShadowTextureConfig(1024,1024,PF_A32B32G32R32F));
    
    sptLt->mShadowCameraNear = 50;
    sptLt->mShadowCameraFar = 200;
    sptLt->mShadowCameraFov = 50;
    sptLt->_UpdateShadowCamera();
    
    DiDebugHelperPtr dbghelper;
    auto mat = DiMaterial::QuickCreate("lambert_v", "lambert_p", SHADER_FLAG_SHADOW_RECEIVER);
    mat->SetAmbient(DiColor(0.8f, 0.8f, 0.8f));
    mat->SetDiffuse(DiColor(0.8f, 0.8f, 0.8f));

    dbghelper = make_shared<DiDebugHelper>();
    sm->GetRootNode()->AttachObject(dbghelper);
    DiMaterialPtr helpermat = DiMaterial::QuickCreate("basic_v", "basic_p", SHADER_FLAG_USE_COLOR);
    helpermat->SetDepthCheck(false);
    dbghelper->SetMaterial(helpermat);
    //dbghelper->AddFrustum(dirlight->GetShadowCamera(0), DiColor::Red);

    hp = dbghelper.get();
    lt = sptLt.get();

#if 0
    DiSimpleShapePtr plane = make_shared<DiSimpleShape>();
    plane->SetShadowCastEnable(false);
    plane->CreatePlane(600, 600);
    plane->SetMaterial(mat);
    plane->GetMaterial()->SetDiffuse(DiColor::White);
    DiCullNode* planeNode = sm->GetRootNode()->CreateChild();
    planeNode->AttachObject(plane);
    planeNode->Translate(0, 0, 0);

    const int size = 1;
    for (int i = -size; i <= size; i++)
    {
        for (int j = -size; j <= size; j++)
        {
            DiMaterialPtr mat = DiMaterial::QuickCreate("lambert_v", "lambert_p", SHADER_FLAG_SKINNED | SHADER_FLAG_SHADOW_RECEIVER);
            mat->SetDiffuse(DiColor(1, 1, 1));
            mat->SetAmbient(DiColor(0.7f, 0.7f, 0.7f));
            
            DiString name;
            name.Format("md_%d_%d", i, j);
            DiAnimModelPtr model = make_shared<DiAnimModel>(name, "robot.model", "robot.motion");
            //DiModelPtr model = make_shared<DiModel>(name, "robot.model");
            model->SetMaterial(mat);
            model->SetShadowCastEnable(true);
            
            model->SetAutoUpdateAnims(true);
            model->GetClipSet()->GetClipController("Walk")->SetEnabled(true);
            
            DiCullNode* cullnode = sm->GetRootNode()->CreateChild();
            cullnode->AttachObject(model);
            cullnode->SetPosition(i * 140.0f, 0, j * 140.0f);
        }
    }
    
#else
    
    DiSimpleShapePtr plane = make_shared<DiSimpleShape>();
    plane->SetShadowCastEnable(false);
    plane->CreatePlane(300, 300);
    plane->SetMaterial(mat);
    plane->GetMaterial()->SetDiffuse(DiColor::White);
    DiCullNode* planeNode = sm->GetRootNode()->CreateChild();
    planeNode->AttachObject(plane);

    DiMaterialPtr m = DiMaterial::QuickCreate("basic_v", "basic_p", SHADER_FLAG_SHADOW_RECEIVER);
    m->SetDiffuse(DiColor(0.9f, 0.9f, 0.9f));
    
    DiSimpleShapePtr box = make_shared<DiSimpleShape>();
    box->SetShadowCastEnable(true);
    box->CreateBox(10);
    box->SetMaterial(m);
    DiCullNode* cullnode = sm->GetRootNode()->CreateChild();
    cullnode->SetPosition(0,5,0);
//.........这里部分代码省略.........

void InitScene()
{
	DiSceneManager* sm = DiBase::Driver->GetSceneManager();

    mat = DiMaterial::QuickCreate("lambert_v", "lambert_p");
    mat->SetDiffuse(DiColor::White);

    sm->SetAmbientColor(DiColor(0.1f, 0.1f, 0.1f, 0.1f));

    DiDirLightPtr dirlight = make_shared<DiDirLight>();
    sm->AttachObject(dirlight);
    dirlight->SetColor(DiColor());
    dirlight->SetDirection(DiVec3(-1, -1, -2).normalisedCopy());

    int amount = 2;

    DiCullNode* parent = sm->GetRootNode();

    for (int i = 0; i < amount; i++) 
    {
        DiSimpleShapePtr model = make_shared<DiSimpleShape>();
        model->CreateBox(10);
        model->SetMaterial(mat);

        DiCullNode* node = parent->CreateChild();
        node->AttachObject(model);
        node->Translate(10, 0, 0);
        nodes.push_back(node);
        parent = node;
    }

    parent = sm->GetRootNode();
    for (int i = 0; i < amount; i++) 
    {
        DiSimpleShapePtr model = make_shared<DiSimpleShape>();
        model->CreateBox(10);
        model->SetMaterial(mat);

        DiCullNode* node = parent->CreateChild();
        node->AttachObject(model);
        node->Translate(-10, 0, 0);
        nodes.push_back(node);
        parent = node;
    }

    parent = sm->GetRootNode();
    for (int i = 0; i < amount; i++) 
    {
        DiSimpleShapePtr model = make_shared<DiSimpleShape>();
        model->CreateBox(10);
        model->SetMaterial(mat);

        DiCullNode* node = parent->CreateChild();
        node->AttachObject(model);
        node->Translate(0, 10, 0);
        nodes.push_back(node);
        parent = node;
    }

    parent = sm->GetRootNode();
    for (int i = 0; i < amount; i++) 
    {
        DiSimpleShapePtr model = make_shared<DiSimpleShape>();
        model->CreateBox(10);
        model->SetMaterial(mat);

        DiCullNode* node = parent->CreateChild();
        node->AttachObject(model);
        node->Translate(0, -10, 0);
        nodes.push_back(node);
        parent = node;
    }

    parent = sm->GetRootNode();
    for (int i = 0; i < amount; i++) 
    {
        DiSimpleShapePtr model = make_shared<DiSimpleShape>();
        model->CreateBox(10);
        model->SetMaterial(mat);

        DiCullNode* node = parent->CreateChild();
        node->AttachObject(model);
        node->Translate(0, 0, 10);
        nodes.push_back(node);
        parent = node;
    }

    parent = sm->GetRootNode();
    for (int i = 0; i < amount; i++)
    {
        DiSimpleShapePtr model = make_shared<DiSimpleShape>();
        model->CreateBox(10);
        model->SetMaterial(mat);

        DiCullNode* node = parent->CreateChild();
        node->AttachObject(model);
        node->Translate(0, 0, -10);
        nodes.push_back(node);
        parent = node;
    }
//.........这里部分代码省略.........

 DiNode* DiCullNode::RemoveChild( unsigned short index )
 {
     DiCullNode *on = static_cast<DiCullNode* >( DiNode::RemoveChild( index ) );
     on->RemoveNodeAndChildren(); 
     return on; 
 }

void SetupWater(DiSceneManager* sm)
{
    // Render targets
    auto reflectMap = DiAssetManager::GetInstance().CreateOrReplaceAsset<DiTexture>("reflect_rt");
    reflectMap->SetDimensions(512, 512);
    reflectMap->SetFormat(PF_A8R8G8B8);
    reflectMap->SetUsage(TU_RENDER_TARGET);
    reflectMap->SetAutoMipmap(false);
    reflectMap->SetAddressing(AM_CLAMP);
    reflectMap->CreateTexture();
    auto reflectRT = reflectMap->GetRenderTarget();

    auto refractMap = DiAssetManager::GetInstance().CreateOrReplaceAsset<DiTexture>("refract_rt");
    refractMap->SetDimensions(512, 512);
    refractMap->SetFormat(PF_A8R8G8B8);
    refractMap->SetUsage(TU_RENDER_TARGET);
    refractMap->SetAutoMipmap(false);
    refractMap->SetAddressing(AM_CLAMP);
    refractMap->CreateTexture();
    auto refractRT = refractMap->GetRenderTarget();
    
    // Water plane 
    DiCullNode* nodePlane = sm->GetRootNode()->CreateChild();
    DiSimpleShapePtr model = make_shared<DiSimpleShape>();
    model->CreatePlane(100);

    auto waterMat = DiMaterial::QuickCreate("pool_fresnel_v", "pool_fresnel_p");
    auto shaderParam = waterMat->GetShaderParameter();

    shaderParam->WriteFloat("scale", 1.0f);
    shaderParam->WriteFloat("scroll", 0.05f);
    shaderParam->WriteFloat("fresnelBias", -0.1f);
    shaderParam->WriteFloat("fresnelScale", 1.8f);
    shaderParam->WriteFloat("fresnelPower", 8.0f);
    shaderParam->WriteFloat("noiseScale", 0.05f);
    shaderParam->WriteFloat4("tintColour", DiVec4(0, 0.05f, 0.05f, 1));
    shaderParam->WriteTexture2D("noiseMap", "waves2.dds");
    shaderParam->WriteTexture2D("reflectMap", "reflect_rt");
    shaderParam->WriteTexture2D("refractMap", "refract_rt");

    model->SetMaterial(waterMat);
    nodePlane->AttachObject(model);
    nodePlane->SetScale(7, 1, 13);

    // Add to scene manager with the callbacks
    DiCamera* cam = sm->GetCamera();
    cam->MoveRelative(DiVec3(0, 0, 700));
    
    sm->AddExtraRenderTarget(refractRT, cam,
        [nodePlane](DiRenderTarget*) {
            nodePlane->SetVisible(false);
        },
        [nodePlane](DiRenderTarget*) {
            nodePlane->SetVisible(true);
        }
    );

    sm->AddExtraRenderTarget(reflectRT, cam,
        [nodePlane, cam](DiRenderTarget*) {
            nodePlane->SetVisible(false);
            cam->EnableReflection(DiPlane(DiVec3::UNIT_Y, 0));
        },
        [nodePlane, cam](DiRenderTarget*) {
            nodePlane->SetVisible(true);
            cam->DisableReflection();
        }
    );
    
    DiPostEffectManager* peMgr = DiBase::Driver->GetMainRenderWindow()->GetPostEffectManager();
	DiPostEffect* bloom = peMgr->GetEffect("Bloom");
    if (bloom)
		bloom->SetEnable(false);
}

    void HonFxerApp::OpenImpl()
    {
        DemiDemo::OpenImpl();
        DI_INSTALL_PLUGIN(DiFx);
        DI_INSTALL_PLUGIN(DiK2);

        Driver->GetMainRenderWindow()->SetForceRenderToCanvas(true);
        
        DiPostEffectManager* peMgr = DiBase::Driver->GetMainRenderWindow()->GetPostEffectManager();
        peMgr->SetManualOutputTarget(DiBase::Driver->GetMainRenderWindow()->GetSceneCanvas());

        DiBase::Driver->GetMainRenderWindow()->GetRenderBuffer()->SetClearColor(DiColor(0.2f, 0.2f, 0.2f));
        DiBase::Driver->GetMainRenderWindow()->GetSceneCanvas()->SetClearColor(DiColor(0.2f, 0.2f, 0.2f));

        DiSceneManager* sm = DiBase::Driver->GetSceneManager();
        sm->SetAmbientColor(DiColor(0.3f, 0.3f, 0.3f));
        DiDirLightPtr dirlight;
        dirlight = make_shared<DiDirLight>();
        DiCullNode* dirNode = sm->GetRootNode()->CreateChild();
        dirNode->AttachObject(dirlight);
        dirlight->SetColor(DiColor());
        dirlight->SetDirection(DiVec3(0, -0.3f, -0.4).normalisedCopy());

        //////////////////////////////////////////////////////////////////////////
        
        new CommandManager();
        CommandManager::getInstance().initialise();
        
        new HotKeyManager();
        HotKeyManager::getInstance().initialise();


        MyGUI::FactoryManager::getInstance().registerFactory<MyGUI::RTTLayer>("Layer");
        MyGUI::FactoryManager::getInstance().registerFactory<MyGUI::FilterNone>("BasisSkin");
        
        MyGUI::ResourceManager::getInstance().load("FxEditorLayers.xml");
        MyGUI::ResourceManager::getInstance().load("FxToolbar.xml");
        MyGUI::ResourceManager::getInstance().load("FxHotkeys.xml");

        DiString userSettings = DiPathLib::GetApplicationPath() + "FxSettings.xml";
        new SettingsManager();
        SettingsManager::getInstance().initialise(userSettings.c_str());

        std::string mLocale = "English";
        MyGUI::LanguageManager::getInstance().setCurrentLanguage(mLocale);

        new MessageBoxManager();
        MessageBoxManager::getInstance().initialise();

        new ColourManager();
        ColourManager::getInstance().initialise();

        MyGUI::ResourceManager::getInstance().load("FxInitialise.xml");

        MyGUI::FactoryManager& factory = MyGUI::FactoryManager::getInstance();
        factory.registerFactory<MyGUI::TreeControl>("Widget");
        factory.registerFactory<MyGUI::TreeControlItem>("Widget");
        MyGUI::ResourceManager::getInstance().load("TreeControlSkin.xml");
        MyGUI::ResourceManager::getInstance().load("TreeItemIcons.xml");

        CommandManager::getInstance().registerCommand("Command_Quit", MyGUI::newDelegate(this, &HonFxerApp::Command_QuitApp));
        CommandManager::getInstance().registerCommand("Command_Export", MyGUI::newDelegate(this, &HonFxerApp::Command_Export));
        CommandManager::getInstance().registerCommand("Command_ResLocation", MyGUI::newDelegate(this, &HonFxerApp::Command_ResLocation));
        CommandManager::getInstance().registerCommand("Command_GameLocation", MyGUI::newDelegate(this, &HonFxerApp::Command_GameLocation));
        CommandManager::getInstance().registerCommand("Command_ViewHelp", MyGUI::newDelegate(this, &HonFxerApp::Command_ViewHelp));

        mMainPane = new MainPaneControl();

        new DialogManager();
        DialogManager::getInstance().initialise();

        DI_NEW DiEditorManager();

#if 0
        DiBase::CommandMgr->ExecuteCommand("selectLast");
        
        DiBase::CommandMgr->ExecuteCommand("createChild ParticleSystem");
        DiBase::CommandMgr->ExecuteCommand("selectLast");
        
        DiBase::CommandMgr->ExecuteCommand("createChild ParticleElement");
        DiBase::CommandMgr->ExecuteCommand("selectLast");
        
        DiBase::CommandMgr->ExecuteCommand("createChild PointEmitter");
        DiBase::CommandMgr->ExecuteCommand("selectLast");
#endif
        
        mSetResLocWindow = new SetResLocWindow();
        mSetResLocWindow->eventEndDialog = MyGUI::newDelegate(this, &HonFxerApp::NotifySetResLocWindowEndDialog);
        
        mSetGameLocWindow = new SetGameLocWindow();
        mSetGameLocWindow->eventEndDialog = MyGUI::newDelegate(this, &HonFxerApp::NotifySetGameLocWindowEndDialog);
        
        mCameraHelper->UseShiftKeyToOrbit(true);
        
        //InitFx_Repeater01();
    }

 DiNode* DiCullNode::RemoveChild( const DiString & name )
 {
     DiCullNode *on = static_cast<DiCullNode*>( DiNode::RemoveChild(  name ) );
     on->RemoveNodeAndChildren( ); 
     return on; 
 }