components/scene/SceneComponent.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            SceneComponent.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           Component wrapper of Irrlicht's ISceneNode.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "SceneComponent.h"
#include "../../core/GameManager.h"


// SceneComponent class
// SceneComponent constructor (default).
SceneComponent::SceneComponent(Entity *parent)
: EntityComponent(parent)
{
    // Common initialisation.
    init();

    // Get a pointer to the scene manager.
    ISceneManager *pScnMgr = GameManager::Instance()->getSceneManager();

    // Set up collision detection for this component.
    mTriSelector = pScnMgr->createTriangleSelectorFromBoundingBox(mSceneNode);
    mMetaSelector = pScnMgr->createMetaTriangleSelector();

    // Set misc. variables.
    mCanAffectParent = false;
    mEvokedParentChange = false;
    mLastPos = getPosition();
}

// SceneComponent constructor (derivatives).
SceneComponent::SceneComponent(Entity *parent, bool isDerived)
: EntityComponent(parent)
{
    init();
}

// SceneComponent deconstructor.
SceneComponent::~SceneComponent()
{
    if(mSceneNode != NULL)     mSceneNode->remove();
    if(mTriSelector != NULL)   mTriSelector->drop();
    if(mMetaSelector != NULL)  mMetaSelector->drop();
}

// Common initialisation method.
void SceneComponent::init()
{
    // Set misc. variables.
    mName = "SceneComponent";

    // Register events.
    pParent->connectEventSignal("onPositionChange", this, &SceneComponent::onPositionChange);
    pParent->connectEventSignal("onRotationChange", this, &SceneComponent::onRotationChange);
    pParent->connectEventSignal("onUpdate", this, &SceneComponent::onUpdate);
    pParent->connectEventSignal("onPause", this, &SceneComponent::onPause);
    pParent->connectEventSignal("onUnPause", this, &SceneComponent::onUnPause);
}

// Returns a direct pointer to the ISceneNode.
ISceneNode* SceneComponent::getSceneNode()
{
    return mSceneNode;
}

// Returns a direct pointer to the meta selector of this component.
IMetaTriangleSelector* SceneComponent::getMetaSelector() const
{
    return mMetaSelector;
}

// Returns a direct pointer to the triangle selector of this component.
ITriangleSelector* SceneComponent::getTriangleSelector() const
{
    return mTriSelector;
}

// Adds an scene node animator to the component.
void SceneComponent::addAnimator(ISceneNodeAnimator *animator)
{
    mSceneNode->addAnimator(animator);
}

// Adds a collision response animator to the component.
void SceneComponent::addCollisionResponseAnimator(const vector3df &ellipsoidRadius,
                                                  const vector3df &gravityPerSecond,
                                                  const vector3df &ellipsoidTranslation,
                                                  f32 slidingValue)
{
    ISceneNodeAnimator *anim = GameManager::Instance()->getSceneManager()->
                                 createCollisionResponseAnimator(mMetaSelector, mSceneNode,
                                 ellipsoidRadius, gravityPerSecond, ellipsoidTranslation,
                                 slidingValue);

    mSceneNode->addAnimator(anim);
    anim->drop();
}

// Adds a fly circle animator to the component.
void SceneComponent::addFlyCircleAnimator(const vector3df &center, f32 radius, f32 speed,
                                          const vector3df &direction)
{
    ISceneNodeAnimator *anim = GameManager::Instance()->getSceneManager()->
                                 createFlyCircleAnimator(center, radius, speed, direction);

    mSceneNode->addAnimator(anim);
    anim->drop();
}

// Adds a fly straight animator to the component.
void SceneComponent::addFlyStraightAnimator(const vector3df &startPoint, const vector3df &endPoint,
                                            u32 timeForWay, bool loop)
{
    ISceneNodeAnimator *anim = GameManager::Instance()->getSceneManager()->
                                 createFlyStraightAnimator(startPoint, endPoint, timeForWay, loop);

    mSceneNode->addAnimator(anim);
    anim->drop();
}

// Searches for a SceneComponent within the given entity and if found adds the triangle selector of
// that component to the meta selector of this component.
void SceneComponent::addToMetaSelector(Entity *entity)
{
    if(entity != NULL && mMetaSelector != NULL)
    {
       SceneComponent *component = static_cast<SceneComponent*>(entity->
                                                                 getComponent("SceneComponent"));

       if(component != NULL)
       {
          ITriangleSelector *selector = component->getTriangleSelector();

          if(selector != NULL)
            mMetaSelector->addTriangleSelector(selector);
       }
    }
}

// Adds the triangle selector of the given component to the meta selector of this component.
void SceneComponent::addToMetaSelector(SceneComponent *component)
{
    if(component != NULL && mMetaSelector != NULL)
    {
        ITriangleSelector *selector = component->getTriangleSelector();

        if(selector != NULL)
          mMetaSelector->addTriangleSelector(selector);
    }
}

// Adds the given triangle selector to the meta selector of this component.
void SceneComponent::addToMetaSelector(ITriangleSelector *selector)
{
    if(selector != NULL && mMetaSelector != NULL)
      mMetaSelector->addTriangleSelector(selector);
}

// Gets the abolute position of the component.
vector3df SceneComponent::getAbsolutePosition() const
{
    return mSceneNode->getAbsolutePosition();
}

// Gets the automatic culling state.
E_CULLING_TYPE  SceneComponent::getAutomaticCulling() const
{
    return mSceneNode->getAutomaticCulling();
}

// Get the axis aligned, not transformed bounding box of this component.
const aabbox3df& SceneComponent::getBoundingBox() const
{
    return mSceneNode->getBoundingBox();
}

// Get amount of materials used by this component.
u32 SceneComponent::getMaterialCount() const
{
    return mSceneNode->getMaterialCount();
}

// Returns the relative transformation of the component.
matrix4 SceneComponent::getRelativeTransformation() const
{
    return mSceneNode->getRelativeTransformation();
}

// Gets the relative position of the component.
const vector3df SceneComponent::getPosition() const
{
    return mSceneNode->getAbsolutePosition() - pParent->getAbsolutePosition();
}

// Gets the rotation of the component.
const vector3df& SceneComponent::getRotation() const
{
    return mSceneNode->getRotation();
}

// Gets the scale of the component.
const vector3df& SceneComponent::getScale() const
{
    return mSceneNode->getScale();
}

// Removes all animators from this component.
void SceneComponent::removeAnimators()
{
    mSceneNode->removeAnimators();
}

// Sets the absolute position of the component.
void SceneComponent::setAbsolutePosition(const vector3df &position)
{
    mSceneNode->setPosition(position);
}

// Enables or disables automatic culling based on the bounding box.
void SceneComponent::setAutomaticCulling(E_CULLING_TYPE state)
{
    mSceneNode->setAutomaticCulling(state);
}

// Sets whether the component can affect the parent entity.
void SceneComponent::setCanAffectParent(bool value)
{
    mCanAffectParent = value;
}

// Sets if debug data like bounding boxes should be drawn.
void SceneComponent::setDebugDataVisible(s32 state)
{
    mSceneNode->setDebugDataVisible(state);
}

// Sets a material flag to a new value.
void SceneComponent::setMaterialFlag(E_MATERIAL_FLAG flag, bool value)
{
    mSceneNode->setMaterialFlag(flag, value);
}

// Loads and sets the texture of the specified layer in all materials of this component to the new
// texture.
void SceneComponent::setMaterialTexture(u32 layer, const std::string &fileName)
{
    // Set up variables.
    AssetGroup *assets = pParent->getAssetGroup();
    ITexture *texture = 0;

    // Retrieve pointer to the texture.
    if(assets != NULL)
    {
        // Unsubscribe from previous asset.
        std::map<u32, std::string>::iterator it = mTextureFileNames.find(layer);

        if(it != mTextureFileNames.end())
          assets->disconnectEventSignal(std::string("textures/") + it->second, this);

        // Get texture.
        TextureProcessor *processor = static_cast<TextureProcessor*>
                                      (assets->getAssetProcessor("textures"));
        texture = processor->getTexture(fileName);

        if(texture)
        {
           assets->connectEventSignal(std::string("textures/") + fileName, this,
                                        &SceneComponent::onTexture);
           mTextureFileNames[layer] = fileName;
        }
    }

    else
      texture = GameManager::Instance()->getDriver()->getTexture(fileName.c_str());

    // Set texture.
    mSceneNode->setMaterialTexture(layer, texture);
}

// Sets the texture of the specified layer in all materials of this component to the new texture.
void SceneComponent::setMaterialTexture(u32 layer, ITexture *texture)
{
    // Check if we need to unsubscribe from an asset group texture.
    AssetGroup *assets = pParent->getAssetGroup();

    if(assets != NULL)
    {
       std::map<u32, std::string>::iterator it = mTextureFileNames.find(layer);

       if(it != mTextureFileNames.end())
       {
          assets->disconnectEventSignal(std::string("textures/") + it->second, this);
          mTextureFileNames.erase(it);
       }
    }

    // Set texture.
    mSceneNode->setMaterialTexture(layer, texture);
}

// Sets the material type of all materials in this component to a new material type.
void SceneComponent::setMaterialType(E_MATERIAL_TYPE type)
{
    mSceneNode->setMaterialType(type);
}

// Sets the relative position of the component.
void SceneComponent::setPosition(const vector3df &position)
{
    mSceneNode->setPosition(pParent->getAbsolutePosition() + position);
}

// Sets the rotation of the component.
void SceneComponent::setRotation(const vector3df &rotation)
{
    mSceneNode->setRotation(pParent->getAbsoluteRotation() + rotation);
}

// Sets the relative scale of the component.
void SceneComponent::setScale(const vector3df &scale)
{
    mSceneNode->setScale(scale);
}

// Sets if the component should be visible or not.
void SceneComponent::setVisible(bool value)
{
    mSceneNode->setVisible(value);
}

// Events
// Updates the position of the component after its parent has been updated.
void SceneComponent::onPositionChange(void *p)
{
    if(!mEvokedParentChange)
    {
       vector3df diff = reinterpret_cast<vector3df*>(p)[0];
       mSceneNode->setPosition(mSceneNode->getPosition() + diff);
    }
}

// Updates the rotation of the component after its parent has been updated.
void SceneComponent::onRotationChange(void *p)
{
    if(!mEvokedParentChange)
    {
       vector3df diff = reinterpret_cast<vector3df*>(p)[0];
       mSceneNode->setRotation(mSceneNode->getRotation() + diff);
    }
}

// Updates the component if the parent is updated.
void SceneComponent::onUpdate(void *p)
{
    if(mCanAffectParent)
    {
       // We're going to check if an animator has changed the position of our scene node.
       // If that's the case we'll have to correct the change upstream.
       vector3df diff = mSceneNode->getPosition() - mLastPos;
       mLastPos = mSceneNode->getPosition();

       if(diff != vector3df(0))
       {
          mEvokedParentChange = true;
          pParent->setAbsolutePosition(pParent->getAbsolutePosition() + diff);
          mEvokedParentChange = false;
       }

       // We're going to check if an animator has changed the rotation of our scene node.
       // If that's the case we'll have to correct the change upstream.
       diff = mSceneNode->getRotation() - mLastRot;
       mLastRot = mSceneNode->getRotation();

       if(diff != vector3df(0))
       {
          mEvokedParentChange = true;
          pParent->setAbsoluteRotation(pParent->getAbsoluteRotation() + diff);
          mEvokedParentChange = false;
       }
    }
}

// Pauses the component if the parent is paused.
void SceneComponent::onPause(void *p)
{
    if(mSceneNode)
    {
       mWasVisible = mSceneNode->isVisible();
       mSceneNode->setVisible(false);
    }
}

// Unpauses the component if the parent is paused.
void SceneComponent::onUnPause(void *p)
{
    if(mSceneNode && mWasVisible)
      mSceneNode->setVisible(true);
}

// Responds to changes of a texture attached to this component.
void SceneComponent::onTexture(void *p)
{
    // Get texture data.
    ITexture *texture = reinterpret_cast<ITexture*>(p);

    // Determine layer.
    std::string fileName = (GameManager::Instance()->getDevice()->getFileSystem()->
                              getFileBasename(texture->getName())).c_str();

    u32 layer;

    std::map<u32, std::string>::iterator it;
    for(it = mTextureFileNames.begin(); it != mTextureFileNames.end(); it++)
    {
       if(it->second == fileName)
       {
           layer = it->first;
           break;
       }
    }

    if(it == mTextureFileNames.end())
      return;

    // Set texture.
    mSceneNode->setMaterialTexture(layer, texture);
}

// Parses for a SceneComponent.
bool SceneComponent::parseXML(IXMLReader *file, Entity *entity)
{
   // Forward declaration.
   SceneComponent *component = NULL;

   // Are we dealing with a SceneComponent?
   if(file->getNodeType() == io::EXN_ELEMENT)
   {
      if(stringw("SceneComponent") == file->getNodeName())
      {
          // Initialise the component.
          component = new SceneComponent(entity);
      }
   }

   if(component == NULL)
     return false;

   // Continue parsing the file.
   while(file->read())
   {
       switch(file->getNodeType())
       {
          case io::EXN_ELEMENT:

             // Derived elements.
             SceneComponent::parseBaseXML(file, component);

             break;

          case io::EXN_ELEMENT_END:

             // </SceneComponent>
             if(stringw("SceneComponent") == file->getNodeName())
               return true;

             break;

         default:

            break;
        }

   }

   // The code should never get here.
   return false;
}

// Parses for the base elements of a SceneComponent.
void SceneComponent::parseBaseXML(IXMLReader *file, SceneComponent *component)
{
    // <CollisionResponseAnimator>
    if(stringw("CollisionResponseAnimator") == file->getNodeName())
    {
       // Retrieve required variables from internal loop.
       vector3df ellipsoidRadius;
       vector3df gravityPerSecond;
       vector3df ellipsoidTranslation;
       f32 slidingValue;

       bool doneParsing = false;

       while(file->read() && !doneParsing)
       {
          switch(file->getNodeType())
          {
             case io::EXN_ELEMENT:

                // <ellipsoidRadius>
                if(stringw("ellipsoidRadius") == file->getNodeName())
                {
                   ellipsoidRadius = vector3df( file->getAttributeValueAsFloat(L"x"),
                                                file->getAttributeValueAsFloat(L"y"),
                                                file->getAttributeValueAsFloat(L"z") );
                }

                // <gravityPerSecond>
                else if(stringw("gravityPerSecond") == file->getNodeName())
                {
                   gravityPerSecond = vector3df( file->getAttributeValueAsFloat(L"x"),
                                                 file->getAttributeValueAsFloat(L"y"),
                                                 file->getAttributeValueAsFloat(L"z") );
                }

                // <ellipsoidTranslation>
                else if(stringw("ellipsoidTranslation") == file->getNodeName())
                {
                   ellipsoidTranslation = vector3df( file->getAttributeValueAsFloat(L"x"),
                                                     file->getAttributeValueAsFloat(L"y"),
                                                     file->getAttributeValueAsFloat(L"z") );
                }

                // <slidingValue>
                else if(stringw("slidingValue") == file->getNodeName())
                   slidingValue = file->getAttributeValueAsFloat(L"value");

                break;

             case io::EXN_ELEMENT_END:

                // </CollisionRespondAnimator>
                if(stringw("CollisionRespondAnimator") == file->getNodeName())
                  doneParsing = true;

                break;

            default:

               break;
          }
       }

       // We create the animator.
       component->addCollisionResponseAnimator(ellipsoidRadius, gravityPerSecond,
                                               ellipsoidTranslation, slidingValue);
    }

    // <FlyCircleAnimator>
    else if(stringw("FlyCircleAnimator") == file->getNodeName())
    {
       // Retrieve required variables from internal loop.
       vector3df center;
       f32 radius;
       f32 speed;
       vector3df direction;

       bool doneParsing = false;

       while(file->read() && !doneParsing)
       {
          switch(file->getNodeType())
          {
             case io::EXN_ELEMENT:

                // <center>
                if(stringw("center") == file->getNodeName())
                {
                   center = vector3df( file->getAttributeValueAsFloat(L"x"),
                                       file->getAttributeValueAsFloat(L"y"),
                                       file->getAttributeValueAsFloat(L"z") );
                }

                // <radius>
                else if(stringw("radius") == file->getNodeName())
                   radius = file->getAttributeValueAsFloat(L"value");

                // <slidingValue>
                else if(stringw("speed") == file->getNodeName())
                   speed = file->getAttributeValueAsFloat(L"value");

                // <direction>
                else if(stringw("direction") == file->getNodeName())
                {
                   direction = vector3df( file->getAttributeValueAsFloat(L"x"),
                                          file->getAttributeValueAsFloat(L"y"),
                                          file->getAttributeValueAsFloat(L"z") );
                }

                break;

             case io::EXN_ELEMENT_END:

                // </FlyCircleAnimator>
                if(stringw("FlyCircleAnimator") == file->getNodeName())
                  doneParsing = true;

                break;

            default:

               break;
          }
       }

       // We create the animator.
       component->addFlyCircleAnimator(center, radius, speed, direction);
    }

    // <FlyStraightAnimator>
    else if(stringw("FlyStraightAnimator") == file->getNodeName())
    {
       // Retrieve required variables from internal loop.
       vector3df startPoint;
       vector3df endPoint;
       u32 timeForWay;
       bool loop;

       bool doneParsing = false;

       while(file->read() && !doneParsing)
       {
          switch(file->getNodeType())
          {
             case io::EXN_ELEMENT:

                // <startPoint>
                if(stringw("startPoint") == file->getNodeName())
                {
                   startPoint = vector3df( file->getAttributeValueAsFloat(L"x"),
                                           file->getAttributeValueAsFloat(L"y"),
                                           file->getAttributeValueAsFloat(L"z") );
                }

                // <endPoint>
                else if(stringw("endPoint") == file->getNodeName())
                {
                   endPoint = vector3df( file->getAttributeValueAsFloat(L"x"),
                                         file->getAttributeValueAsFloat(L"y"),
                                         file->getAttributeValueAsFloat(L"z") );
                }

                // <timeForWay>
                else if(stringw("timeForWay") == file->getNodeName())
                   timeForWay = (u32)file->getAttributeValueAsInt(L"timeForWay");

                // <slidingValue>
                else if(stringw("slidingValue") == file->getNodeName())
                {
                   stringc value = file->getAttributeValue(L"value");
                   loop = (value == "true") ? true : false ;
                }

                break;

             case io::EXN_ELEMENT_END:

                // </FlyStraightAnimator>
                if(stringw("FlyStraightAnimator") == file->getNodeName())
                  doneParsing = true;

                break;

            default:

               break;
          }
       }

       // We create the animator.
       component->addFlyStraightAnimator(startPoint, endPoint, timeForWay, loop);
    }

    // <absolutePosition>
    else if(stringw("absolutePosition") == file->getNodeName())
    {
       component->setAbsolutePosition( vector3df(file->getAttributeValueAsFloat(L"x"),
                                                 file->getAttributeValueAsFloat(L"y"),
                                                 file->getAttributeValueAsFloat(L"z") ) );
    }

    // <automaticCulling>
    else if(stringw("automaticCulling") == file->getNodeName())
    {
        stringc value = file->getAttributeValue(L"value");
        E_CULLING_TYPE type;

#define retrieveCullingType(x) \
else if(value == #x) \
  type = x

       if(value == "")
         type = EAC_OFF; // Dummy behaviour.

       retrieveCullingType(EAC_OFF);
       retrieveCullingType(EAC_BOX);
       retrieveCullingType(EAC_FRUSTUM_BOX);
       retrieveCullingType(EAC_FRUSTUM_SPHERE);

#undef retrieveCullingType

       component->setAutomaticCulling(type);
    }

    // <canAffectParent>
    else if(stringw("canAffectParent") == file->getNodeName())
    {
       stringc value = file->getAttributeValue(L"value");
       component->setCanAffectParent( (value == "true") ? true : false );
    }

    // <materialFlag>
    else if(stringw("materialFlag") == file->getNodeName())
    {
       stringc materialFlag = file->getAttributeValue(L"flag");
       E_MATERIAL_FLAG flag;

#define retrieveMaterialFlag(x) \
else if(materialFlag == #x) \
  flag = x

       if(materialFlag == "")
         flag = EMF_WIREFRAME; // Dummy behaviour.

       retrieveMaterialFlag(EMF_WIREFRAME);
       retrieveMaterialFlag(EMF_POINTCLOUD);
       retrieveMaterialFlag(EMF_GOURAUD_SHADING);
       retrieveMaterialFlag(EMF_LIGHTING);
       retrieveMaterialFlag(EMF_ZBUFFER);
       retrieveMaterialFlag(EMF_ZWRITE_ENABLE);
       retrieveMaterialFlag(EMF_BACK_FACE_CULLING);
       retrieveMaterialFlag(EMF_FRONT_FACE_CULLING);
       retrieveMaterialFlag(EMF_BILINEAR_FILTER);
       retrieveMaterialFlag(EMF_TRILINEAR_FILTER);
       retrieveMaterialFlag(EMF_ANISOTROPIC_FILTER);
       retrieveMaterialFlag(EMF_FOG_ENABLE);
       retrieveMaterialFlag(EMF_NORMALIZE_NORMALS);
       retrieveMaterialFlag(EMF_TEXTURE_WRAP);

#undef retrieveMaterialFlag

       stringc value = file->getAttributeValue(L"value");

       component->setMaterialFlag(flag, (value == "true") ? true : false );
    }

    // <materialTexture>
    else if(stringw("materialTexture") == file->getNodeName())
    {
       stringc fileName = file->getAttributeValue(L"fileName");
       component->setMaterialTexture(file->getAttributeValueAsInt(L"layer"), fileName.c_str());
    }

    // <materialType>
    else if(stringw("materialType") == file->getNodeName())
    {
       stringc value = file->getAttributeValue(L"value");
       E_MATERIAL_TYPE type;

#define retrieveMaterialType(x) \
else if(value == #x) \
  type = x

       if(value == "")
         type = EMT_SOLID; // Dummy behaviour.

       retrieveMaterialType(EMT_SOLID);
       retrieveMaterialType(EMT_SOLID_2_LAYER);
       retrieveMaterialType(EMT_LIGHTMAP);
       retrieveMaterialType(EMT_LIGHTMAP_ADD);
       retrieveMaterialType(EMT_LIGHTMAP_M2);
       retrieveMaterialType(EMT_LIGHTMAP_M4);
       retrieveMaterialType(EMT_LIGHTMAP_LIGHTING);
       retrieveMaterialType(EMT_LIGHTMAP_LIGHTING_M2);
       retrieveMaterialType(EMT_LIGHTMAP_LIGHTING_M4);
       retrieveMaterialType(EMT_DETAIL_MAP);
       retrieveMaterialType(EMT_SPHERE_MAP);
       retrieveMaterialType(EMT_REFLECTION_2_LAYER);
       retrieveMaterialType(EMT_TRANSPARENT_ADD_COLOR);
       retrieveMaterialType(EMT_TRANSPARENT_ALPHA_CHANNEL);
       retrieveMaterialType(EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
       retrieveMaterialType(EMT_TRANSPARENT_VERTEX_ALPHA);
       retrieveMaterialType(EMT_TRANSPARENT_REFLECTION_2_LAYER);
       retrieveMaterialType(EMT_NORMAL_MAP_SOLID);
       retrieveMaterialType(EMT_NORMAL_MAP_TRANSPARENT_ADD_COLOR);
       retrieveMaterialType(EMT_NORMAL_MAP_TRANSPARENT_VERTEX_ALPHA);
       retrieveMaterialType(EMT_PARALLAX_MAP_SOLID);
       retrieveMaterialType(EMT_PARALLAX_MAP_TRANSPARENT_ADD_COLOR);
       retrieveMaterialType(EMT_PARALLAX_MAP_TRANSPARENT_VERTEX_ALPHA);
       retrieveMaterialType(EMT_ONETEXTURE_BLEND);

#undef retrieveMaterialType

       component->setMaterialType(type);
    }

    // <position>
    else if(stringw("position") == file->getNodeName())
    {
       component->setPosition( vector3df(file->getAttributeValueAsFloat(L"x"),
                                         file->getAttributeValueAsFloat(L"y"),
                                         file->getAttributeValueAsFloat(L"z") ) );
    }

    // <rotation>
    else if(stringw("rotation") == file->getNodeName())
    {
       component->setRotation( vector3df(file->getAttributeValueAsFloat(L"x"),
                                         file->getAttributeValueAsFloat(L"y"),
                                         file->getAttributeValueAsFloat(L"z") ) );
    }

    // <scale>
    else if(stringw("scale") == file->getNodeName())
    {
       component->setScale( vector3df(file->getAttributeValueAsFloat(L"x"),
                                      file->getAttributeValueAsFloat(L"y"),
                                      file->getAttributeValueAsFloat(L"z") ) );
    }

    // <visisble>
    else if(stringw("visible") == file->getNodeName())
    {
       stringc value = file->getAttributeValue(L"value");
       component->setVisible( (value == "true") ? true : false );
    }
}

// End of File

---