C++ SceneNode::addChild方法代码示例

void Actors::updateObjectCell(const MWWorld::Ptr &old, const MWWorld::Ptr &cur)
{
    Ogre::SceneNode *node;
    MWWorld::CellStore *newCell = cur.getCell();

    CellSceneNodeMap::const_iterator celliter = mCellSceneNodes.find(newCell);
    if(celliter != mCellSceneNodes.end())
        node = celliter->second;
    else
    {
        node = mRootNode->createChildSceneNode();
        mCellSceneNodes[newCell] = node;
    }
    node->addChild(cur.getRefData().getBaseNode());

    PtrAnimationMap::iterator iter = mAllActors.find(old);
    if(iter != mAllActors.end())
    {
        Animation *anim = iter->second;
        mAllActors.erase(iter);
        anim->updatePtr(cur);
        mAllActors[cur] = anim;
    }

    mRendering->updateWaterRippleEmitterPtr (old, cur);
}

void EC_WaterPlane::AttachEntity()
{
    if (attached_ || entity_ == 0)
        return;

    EC_Placeable* placeable = dynamic_cast<EC_Placeable* >(FindPlaceable().get());
    
    // If there exist placeable attach node and entity to it
    if (placeable != 0 )
    {
        Ogre::SceneNode* node = placeable->GetSceneNode();
        node->addChild(node_);
        node_->attachObject(entity_);
        node_->setVisible(true);
    }
    else
    {
        // There is no placeable attacht entity to OgreSceneRoot 
        Ogre::SceneManager* sceneMgr = world_.lock()->GetSceneManager();
        node_->attachObject(entity_);
        sceneMgr->getRootSceneNode()->addChild(node_);
        node_->setVisible(true);
        attachedToRoot_ = true;
    }

    attached_ = true;
}

VOID CFairyObject::SetVisible(BOOL bVisible)
{
	if(m_bVisible == bVisible) return;

	//确认是人物模型
	if(m_pFairyObj->getType() != EOBJ_TYPE_ACTOR) return;
	
	//确认资源已经Load
	Fairy::Actor* pActor = ((Fairy::ActorObject*)m_pFairyObj.get())->getActor();
	if(!pActor) return;

	Ogre::SceneNode* pParentNode = ((Fairy::ActorObject*)m_pFairyObj.get())->getSceneNode();
	Ogre::SceneNode* pActorNode = (((Fairy::ActorObject*)m_pFairyObj.get())->getActor())->getSceneNode();

	if(bVisible)
	{
		pParentNode->addChild(pActorNode);
	}
	else
	{
		pParentNode->removeChild(pActorNode);
	}

	m_bVisible = bVisible;
}

void EC_OgreMovableTextOverlay::AttachNode()
{
    // Using the link scene node is necessary here so that the overlays can use the _update() trick to avoid stutter
    if ((node_) && (!attached_) && (placeable_))
    {
        Ogre::SceneNode* parent =
            checked_static_cast<EC_OgrePlaceable*>(placeable_.get())->GetLinkSceneNode();
        parent->addChild(node_);
        attached_ = true;
    }
}

void Objects::updateObjectCell(const MWWorld::Ptr &old, const MWWorld::Ptr &cur)
{
    Ogre::SceneNode *node;
    MWWorld::CellStore *newCell = cur.getCell();

    if(mCellSceneNodes.find(newCell) == mCellSceneNodes.end()) {
        node = mRootNode->createChildSceneNode();
        mCellSceneNodes[newCell] = node;
    } else {
        node = mCellSceneNodes[newCell];
    }
    node->addChild(cur.getRefData().getBaseNode());
}

void EC_Mesh::AttachEntity()
{
    if ((attached_) || (!entity_) || (!placeable_))
        return;
    
    EC_Placeable* placeable = checked_static_cast<EC_Placeable*>(placeable_.get());
    Ogre::SceneNode* node = placeable->GetSceneNode();
    node->addChild(adjustment_node_);
    adjustment_node_->attachObject(entity_);

    // Honor the EC_Placeable's isVisible attribute by enforcing its values on this mesh.
    adjustment_node_->setVisible(placeable->visible.Get());

    attached_ = true;
}

void
Objects::updateObjectCell(const MWWorld::Ptr &ptr)
{
    Ogre::SceneNode *node;
    MWWorld::CellStore *newCell = ptr.getCell();

    if(mCellSceneNodes.find(newCell) == mCellSceneNodes.end()) {
        node = mMwRoot->createChildSceneNode();
        mCellSceneNodes[newCell] = node;
    } else {
        node = mCellSceneNodes[newCell];
    }
    node->addChild(ptr.getRefData().getBaseNode());

    /// \note Still unaware how to move aabb and static w/o full rebuild,
    /// moving static objects may cause problems
    insertMesh(ptr, MWWorld::Class::get(ptr).getModel(ptr));
}

void Camera::onSetTarget(const GameHandle& target)
{
	//! \hack const offset for camera
	v3 offset(0.0f, 3.0f, -14);

	Ogre::SceneManager* sceneMgr = Ogre::Root::getSingleton().getSceneManager(BFG_SCENEMANAGER);

	if (!sceneMgr->hasSceneNode(stringify(target)))
	{
		errlog << "Target (" << stringify(target) << ") for camera (" << mHandle << ") does not exist!";
		return;
	}

	Ogre::SceneNode* newParent = sceneMgr->getSceneNode(stringify(target));
	Ogre::SceneNode* oldParent = mCameraNode->getParentSceneNode();
	oldParent->removeChild(mCameraNode);
	newParent->addChild(mCameraNode);

	mCameraNode->setPosition(toOgre(offset));
}

void EC_WaterPlane::ComponentAdded(IComponent* component, AttributeChange::Type type)
{
    if (component->TypeName() == EC_Placeable::TypeNameStatic())
    {
        DetachEntity();

        EC_Placeable* placeable = static_cast<EC_Placeable* >(component);
        if (placeable == 0)
            return;
        if (entity_ == 0)
            return;

        Ogre::SceneNode* node = placeable->GetSceneNode();
        
        node->addChild(node_);
        node_->attachObject(entity_);
        node_->setVisible(true);

        attached_ = true;
    }
}

	void createScene()
	{ 

		 mSceneMgr->setAmbientLight(Ogre::ColourValue(1.0, 1.0, 1.0));

		 
	/*			
		Ogre::Entity* entMesh01 = mSceneMgr->createEntity("MyEntity1","ogrehead.mesh");
		Ogre::SceneNode* nodeMesh01 = mSceneMgr->createSceneNode("NodeMesh01");
		mSceneMgr->getRootSceneNode()->addChild(nodeMesh01);
		nodeMesh01->setPosition(0.0,0.0,0.0);
		nodeMesh01->attachObject(entMesh01);
	*/	
		
		Ogre::Entity* ent01 = mSceneMgr->createEntity("MyEntity1","ejes01.mesh");
		Ogre::SceneNode* node01 = mSceneMgr->createSceneNode("Node01");
		mSceneMgr->getRootSceneNode()->addChild(node01);
		node01->attachObject(ent01);

		Ogre::Entity* ent02 = mSceneMgr->createEntity("MyEntity2","cuadriculaX01.mesh");
		Ogre::SceneNode* node02 = mSceneMgr->createSceneNode("Node02");
		mSceneMgr->getRootSceneNode()->addChild(node02);
		node02->attachObject(ent02);

		Ogre::SceneNode* nodeSinbad = mSceneMgr->createSceneNode("NodeSinbad");
		Ogre::SceneNode* nodeEjeSinbad = mSceneMgr->createSceneNode("NodeEjeSinbad");
		Ogre::SceneNode* nodeNinja = mSceneMgr->createSceneNode("NodeNinja");

		Ogre::Entity* entSinbad = mSceneMgr->createEntity("MyEntitySinbad","sinbad.mesh");
		Ogre::Entity* entEjeSinbad = mSceneMgr->createEntity("MyEntityEjeSinbad","ejes01.mesh");
		Ogre::Entity* entNinja = mSceneMgr->createEntity("MyEntityNinja","ninja.mesh");
		
		mSceneMgr->getRootSceneNode()->addChild(nodeEjeSinbad);
		nodeEjeSinbad->attachObject(entEjeSinbad);
		nodeEjeSinbad->addChild(nodeSinbad);
		nodeEjeSinbad->addChild(nodeNinja);


		nodeSinbad->attachObject(entSinbad);
		nodeNinja->attachObject(entNinja);

		//eje
		nodeEjeSinbad->setScale(0.6,0.6,0.6);
		nodeEjeSinbad->setPosition(5.0,0.0,0.0);
		nodeEjeSinbad->translate(2.0,0.0,2.0);
		nodeEjeSinbad->yaw(Ogre::Degree(45.0f)); //rota en Y
		//nodeEjeSinbad->pitch(Ogre::Degree(45.0f));//rota en X
		//nodeEjeSinbad->roll(Ogre::Degree(45.0f));//rota en Z

		//Hijo Sinbad
		nodeSinbad->setScale(0.8,0.8,0.8);
		nodeSinbad->translate(0.0,0.0,8.0,Ogre::Node::TS_WORLD);

		//Hijo Ninja
		nodeNinja->setScale(0.04,0.04,0.04);
		nodeNinja->yaw(Ogre::Degree(180.0f));
		nodeNinja->setPosition(4.0,-4.0,5.0);

		/*nodeSinbad->attachObject(entEjeSinbad);
		nodeSinbad->attachObject(ejeSinbad);
		*/

	}

void EC_Clone::Create()
{
    if (renderer_.expired())
        return;

    Ogre::SceneManager *scene = renderer_.lock()->GetSceneManager();
    assert(scene);
    if (!scene)
        return;

    Scene::Entity *entity = GetParentEntity();
    assert(entity);
    if (!entity)
        return;

    EC_Placeable *placeable = entity->GetComponent<EC_Placeable>().get();
    assert(placeable);
    if (!placeable)
        return;

    Ogre::SceneManager *sceneMgr = renderer_.lock()->GetSceneManager();
    assert(sceneMgr);
    if (!sceneMgr)
        return;

    Ogre::Entity *originalEntity  = 0;
    Ogre::SceneNode *originalNode = 0;

    // Check out if this entity has EC_Mesh or EC_OgreCustomObject.
    if (entity->GetComponent(EC_Mesh::TypeNameStatic()))
    {
        EC_Mesh *ec_mesh= entity->GetComponent<EC_Mesh>().get();
        assert(ec_mesh);

        originalEntity = ec_mesh->GetEntity();
        //originalNode = placeable->GetSceneNode();
        originalNode = ec_mesh->GetAdjustmentSceneNode();

        sceneNode_ = sceneMgr->createSceneNode();
        sceneNode_->setPosition(originalNode->getPosition());
        originalNode->addChild(sceneNode_);
    }
    else if(entity->GetComponent(EC_OgreCustomObject::TypeNameStatic()))
    {
        EC_OgreCustomObject *ec_custom = entity->GetComponent<EC_OgreCustomObject>().get();
        assert(ec_custom);
        if (!ec_custom->IsCommitted())
        {
            LogError("Mesh entity have not been created for the target primitive. Cannot create EC_Clone.");
            return;
        }

        originalEntity = ec_custom->GetEntity();
        originalNode = placeable->GetSceneNode();

        sceneNode_ = sceneMgr->createSceneNode();
        sceneNode_->setPosition(originalNode->getPosition());
        originalNode->addChild(sceneNode_);
    }
    else
    {
        LogError("This entity doesn't have either EC_Mesh or EC_OgreCustomObject present. Cannot create EC_Clone.");
        return;
    }

    assert(originalEntity);
    if (!originalEntity)
        return;

    assert(sceneNode_);
    if (!sceneNode_)
        return;

    // Clone the Ogre entity.
    cloneName_ = renderer_.lock()->GetUniqueObjectName("EC_Clone_ent");
    entityClone_ = originalEntity->clone(cloneName_);
    assert(entityClone_);

    // Disable casting of shadows for the clone.
    entityClone_->setCastShadows(false);

    ///\todo If original entity has skeleton, (try to) link it to the clone.
/*
    if (originalEntity->hasSkeleton())
    {
        Ogre::SkeletonInstance *skel = originalEntity->getSkeleton();
        // If sharing a skeleton, force the attachment mesh to use the same skeleton
        // This is theoretically quite a scary operation, for there is possibility for things to go wrong
        Ogre::SkeletonPtr entity_skel = originalEntity->getMesh()->getSkeleton();
        if (entity_skel.isNull())
        {
            LogError("Cannot share skeleton for attachment, not found");
        }
        else
        {
            try
            {
                entityClone_->getMesh()->_notifySkeleton(entity_skel);
            }
            catch (Ogre::Exception &e)
//.........这里部分代码省略.........

    void createScene() {
        Ogre::SceneNode* nroca = mSceneMgr->createSceneNode("nroca");
        Ogre::Entity *roca = mSceneMgr->createEntity("roca", "cube.mesh");
        nroca->attachObject(roca);
        mSceneMgr->getRootSceneNode()->addChild(nroca);

        Ogre::SceneNode* ntronco = mSceneMgr->createSceneNode("ntronco");
        Ogre::Entity *tronco = mSceneMgr->createEntity("tronco", "cube.mesh");
        ntronco->attachObject(tronco);
        mSceneMgr->getRootSceneNode()->addChild(ntronco);

        Ogre::SceneNode* ncabeza = mSceneMgr->createSceneNode("ncabeza");
        Ogre::Entity *cabeza = mSceneMgr->createEntity("cabeza", "cube.mesh");
        ncabeza->attachObject(cabeza);
        ntronco->addChild(ncabeza);

        Ogre::SceneNode* nbase = mSceneMgr->createSceneNode("nbase");
        Ogre::Entity *base = mSceneMgr->createEntity("base", "cube.mesh");
        nbase->attachObject(base);
        ncabeza->addChild(nbase);

        Ogre::SceneNode* nsombrero = mSceneMgr->createSceneNode("nsombrero");
        Ogre::Entity *sombrero = mSceneMgr->createEntity("sombrero", "cube.mesh");
        nsombrero->attachObject(sombrero);
        nbase->addChild(nsombrero);

        Ogre::SceneNode* nbrazoizq = mSceneMgr->createSceneNode("nbrazoizq");
        Ogre::Entity *brazoizq = mSceneMgr->createEntity("brazoizq", "cube.mesh");
        nbrazoizq->attachObject(brazoizq);
        ntronco->addChild(nbrazoizq);

        Ogre::SceneNode* nbrazoder = mSceneMgr->createSceneNode("nbrazoder");
        Ogre::Entity *brazoder = mSceneMgr->createEntity("brazoder", "cube.mesh");
        nbrazoder->attachObject(brazoder);
        ntronco->addChild(nbrazoder);

        Ogre::SceneNode* npiernaizq = mSceneMgr->createSceneNode("npiernaizq");
        Ogre::Entity *piernaizq = mSceneMgr->createEntity("piernaizq", "cube.mesh");
        npiernaizq->attachObject(piernaizq);
        ntronco->addChild(npiernaizq);

        Ogre::SceneNode* npiernader = mSceneMgr->createSceneNode("npiernader");
        Ogre::Entity *piernader = mSceneMgr->createEntity("piernader", "cube.mesh");
        npiernader->attachObject(piernader);
        ntronco->addChild(npiernader);

        Ogre::SceneNode* npieder = mSceneMgr->createSceneNode("npieder");
        Ogre::Entity *pieder = mSceneMgr->createEntity("pieder", "cube.mesh");
        npieder->attachObject(pieder);
        npiernader->addChild(npieder);



        nroca->setPosition(0,7,0);
        nroca->setScale(7,7,7);
        nroca->pitch(Degree(30));
        nroca->roll(Degree(-45));
        ntronco->setPosition(-20,4,0);
        ntronco->setScale(1,3,1);
        ntronco->roll(Degree(17));
        ncabeza->setPosition(0.25,1.35,0);
        ncabeza->setScale(1,0.33,1);
        ncabeza->roll(Degree(-10));
        nbase->setPosition(0.25,2,0);
        nbase->setScale(1,0.15,1);
        nbase->roll(Degree(-30));
        nsombrero->setPosition(0,2.5,0);
        nsombrero->setScale(0.5,3.5,0.5);
        nbrazoder->setScale(0.5,1,0.5);
        nbrazoder->setPosition(-2,0.65,-2.25);
        nbrazoder->roll(Degree(90));
        nbrazoder->pitch(Degree(-30));
        nbrazoizq->setScale(0.5,1,0.5);
        nbrazoizq->setPosition(-2,0.65,2.25);
        nbrazoizq->roll(Degree(100));
        nbrazoizq->pitch(Degree(30));
        npiernaizq->setPosition(-1.75,-1.75,-0.25);
        npiernaizq->setScale(0.5,1,0.5);
        npiernaizq->roll(Degree(-45));
        npiernader->setPosition(1,-1.35,0.5);
        npiernader->setScale(0.5,0.5,0.5);
        npiernader->roll(Degree(35));
        npieder->setPosition(2.25,-1.25,1.75);
        npieder->roll(Degree(90));




        Ogre::Plane pl1(Ogre::Vector3::UNIT_Y, -5);
        Ogre::MeshManager::getSingleton().createPlane("pl1",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,pl1,200,200,1,1,true,1,20,20,Ogre::Vector3::UNIT_Z);
        Ogre::SceneNode* nground = mSceneMgr->createSceneNode("ground");
        Ogre::Entity *ground = mSceneMgr->createEntity("pEnt","pl1");
        ground->setMaterialName("Ground");
        nground->attachObject(ground);
        mSceneMgr->getRootSceneNode()->addChild(nground);

        mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5, 0.5, 0.5));
    }