void Light::leaveScene() {
getSceneNode()->detachObject(light);
getScene()->getSceneManager()->destroyLight(light);
light = nullptr;
VisualComponent::leaveScene();
}
void moveit_rviz_plugin::PerLinkSubObjBase::changed()
{
shapes_.reset();
centers_.clear();
radii_.clear();
if (!getBool())
return;
getGeom(robot_relative_, centers_, radii_);
if (centers_.empty())
return;
shapes_.reset(new ShapesDisplay(getSceneNode(), base_->getColor(), base_->getSize()));
if (centers_.size() == radii_.size() || radii_.size() == 1)
{
shapes_->addSpheres(centers_, radii_);
base_->setStyle(PerLinkObjBase::SPHERES);
}
else if (base_->getStyle() == PerLinkObjBase::SPHERES)
{
shapes_->addSpheres(centers_, base_->getSize() * 0.5);
}
else
{
shapes_->addPoints(centers_);
}
}
//==============================================================================
void AnimationEvent::update(F32 prevUpdateTime, F32 crntTime)
{
ANKI_ASSERT(getSceneNode());
MoveComponent& move = getSceneNode()->getComponent<MoveComponent>();
Vec3 pos;
Quat rot;
F32 scale = 1.0;
m_anim->interpolate(0, crntTime, pos, rot, scale);
Transform trf;
trf.setOrigin(pos.xyz0());
trf.setRotation(Mat3x4(rot));
trf.setScale(scale);
move.setLocalTransform(trf);
}
void Camera::onDetachedToScene()
{
Scene* scene = getSceneNode()->getAttachedScene();
if (scene)
{
scene->unRegisterLastUpdate(this);
}
}
void Camera::onAttachedToScene()
{
Scene* scene = getSceneNode()->getAttachedScene();
if (scene)
{
scene->registerLastUpdate(this, CAMERA_UPDATE_PRIORITY, std::bind(&Camera::lastUpdate, this));
}
}
void OctreeSceneManager::destroySceneNode( const String &name )
{
OctreeNode * on = static_cast < OctreeNode* > ( getSceneNode( name ) );
if ( on != 0 )
_removeOctreeNode( on );
SceneManager::destroySceneNode( name );
}
//-------------------------------------------------------------------
void Vob::updateInvisibleVisual()
{
destroyInvisibleVisual();
if(!mInvisibleVisual.empty())
{
MeshExPtr mesh = MeshManagerEx::getSingleton().create(mInvisibleVisual);
SceneNode* sceneNode = getSceneNode();
SceneManagerEx* sceneMgr = (SceneManagerEx*) sceneNode->getCreator();
mInvisibleEntity = sceneMgr->createEntity(mesh, SceneQueryMask::VOB);
sceneNode->attachObject(mInvisibleEntity);
}
}
void Light::enterScene(Scene* scene) {
VisualComponent::enterScene(scene);
light = createLight();
setEnabled(isEnabled());
setDiffuseColour(getDiffuseColour());
setSpecularColour(getSpecularColour());
setAttenuation(getAttenuation());
getSceneNode()->attachObject(light);
}
//-----------------------------------------------------------------------
void ActorObject::createActor(void)
{
assert(!mActor);
assert(mProxy && !mActorName.empty());
Ogre::SceneNode* parent = getSceneNode();
assert(parent);
Ogre::SceneManager* creator = parent->getCreator();
assert(creator);
mActor = new Actor(mSystem, parent->getName(), mActorName, parent);
mActor->setUserObject(mProxy);
}
//-----------------------------------------------------------------------
void ModelObject::createModel(void)
{
assert(!mModel);
assert(mProxy && !mModelName.empty());
Ogre::SceneNode* parent = getSceneNode();
assert(parent);
mModel = new Model(parent, mModelName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
mModel->setUserObject(mProxy);
mModel->setAnimationType(mSystem->_determineAnimationType(mAnimationLevel));
mModel->setCastShadows(mCastShadows);
}
// Destroy a Scene Node by name.
void PCZSceneManager::destroySceneNode( const String &name )
{
SceneNode * on = ( getSceneNode( name ) );
if ( on != 0 )
{
// remove references to the node from zones
removeSceneNode( on );
}
// destroy the node
SceneManager::destroySceneNode( name );
}
//==============================================================================
void MoveEvent::update(F32 prevUpdateTime, F32 crntTime)
{
SceneNode* node = getSceneNode();
ANKI_ASSERT(node);
MoveComponent& move = node->getComponent<MoveComponent>();
Transform trf = move.getLocalTransform();
F32 factor = sin(getDelta(crntTime) * getPi<F32>());
trf.getOrigin() = interpolate(m_originalPos, m_newPos, factor);
move.setLocalTransform(trf);
}
Error JitterMoveEvent::update(F32 prevUpdateTime, F32 crntTime)
{
SceneNode* node = getSceneNode();
ANKI_ASSERT(node);
MoveComponent& move = node->getComponent<MoveComponent>();
Transform trf = move.getLocalTransform();
F32 factor = sin(getDelta(crntTime) * PI);
trf.getOrigin() = linearInterpolate(m_originalPos, m_newPos, factor);
move.setLocalTransform(trf);
return ErrorCode::NONE;
}
//-----------------------------------------------------------------------
void ParticleSystemObject::createParticleSystem(void)
{
assert( mParticleSystem == NULL );
assert(!mParticleSystemName.empty());
Ogre::SceneNode* parent = getSceneNode();
if (parent)
{
mParticleSystem = parent->getCreator()->createParticleSystem( parent->getName(), mParticleSystemName );
assert(mParticleSystem);
// Set render queue for particle system, the particle system should be render after world geometry 2
mParticleSystem->setRenderQueueGroup(Ogre::RENDER_QUEUE_8);
parent->attachObject(mParticleSystem);
}
}
//-----------------------------------------------------------------------
void BulletObject::createBulletSystem(void)
{
assert( mBulletSystem == NULL );
assert(!mBulletSystemName.empty());
Ogre::SceneNode* parent = getSceneNode();
if (parent)
{
mBulletSystem = BulletSystemManager::getSingleton().createBulletSystem( mBulletSystemName );
assert(mBulletSystem);
mBulletSystem->setPosition(Ogre::Vector3::ZERO);
// the scene node of placement object will be the parent scene node of
// effect object, so the position of the scene node will be the position of
// the effect.
mBulletSystem->createSceneNode(parent);
}
}
EnemyShip::EnemyShip(PlayerShip *player, irr::core::vector3df spawnPosition, int firingSpeed, irr::ITimer* timerReference, const irr::io::path& pathOfMesh, const irr::io::path& pathOfTexture, irr::scene::ISceneManager* sceneManagerReference, const unsigned short &startingLives)
: Ship(spawnPosition, player->getMovementSpeed(), firingSpeed, -1, timerReference, pathOfMesh, pathOfTexture, sceneManagerReference, TYPE_SHIP_ENEMY, startingLives){
//rotate to the right position
getSceneNode()->setRotation(irr::core::vector3df(0, 180, 0));
//set the player
playerTarget = player;
//init variables
activeDistance = 125.0f;
canMove = false;
timeElapsed = 0;
combatStartTime = 0.5f;
rewardScore = true;
scoreAmount = 5000;
//Make the turn speed constant
turnSpeed = 100;
}
//-----------------------------------------------------------------------
void EffectObject::createEffect(void)
{
assert( mEffect == NULL );
assert(!mEffectName.empty());
Ogre::SceneNode* parent = getSceneNode();
if (parent)
{
mEffect = EffectManager::getSingleton().createEffect( mEffectName );
assert(mEffect);
Fairy::TransformInfos tempTransformInfos;
Fairy::TransformInfo tempTransformInfo(Ogre::Vector3::ZERO);
tempTransformInfos.push_back(tempTransformInfo);
mEffect->setExtraTransformInfos(tempTransformInfos);
// the scene node of placement object will be the parent scene node of
// effect object, so the position of the scene node will be the position of
// the effect.
mEffect->createSceneNode(parent);
}
}
void Camera::onAttached()
{
dImpl->_transformChangedCallbackId = getSceneNode()->getTransform()->addChangedCallback(std::bind(&Camera::onTransformChanged, this, std::placeholders::_1));
onTransformChanged(*getSceneNode()->getTransform());
}
void Camera::onDettached()
{
getSceneNode()->getTransform()->removeChangedCallback(dImpl->_transformChangedCallbackId);
}
