OMKOffsetExtension.cpp

Go to the documentation of this file.

#include "OMKOffsetExtension.h"
#include "OMKExtensibleSimulatedObject.inl"
#include "OMKParametersAccessor.inl"
//-------------------------------------------------------------------------
using namespace OMK ;
using namespace OMK::Type ;

//=========================================================================
// PreOffsetExtension
//=========================================================================
REGISTER_EXTENSION_FACTORY( PreOffsetExtension, "PreOffset" ) ;
//-------------------------------------------------------------------------
PreOffsetExtension::PreOffsetExtension( ExtensibleSimulatedObject* owner,
                                  const Name& id,
                                  bool registerExtension )
: ExtensionT< ExtensibleSimulatedObject >( owner, id, registerExtension ),
  _attributeAccessor( 0 ),
  _offset( id, OMK::Type::Transform::sk_identity ),
  _ignoreRotate( false ),
  _ignoreScale( false )
{
  // add the attribute Offset to the object
  _owner->addAttribute( _offset ) ;
}
//-------------------------------------------------------------------------
PreOffsetExtension::~PreOffsetExtension()
{
}
//-------------------------------------------------------------------------
bool PreOffsetExtension::loadExtensionParameters(
  const ConfigurationParameterDescriptor * node )
{
  // Retrieve the visual objects
  bool ok = true ;
  // Offset value
  _offset.loadParameters( node, "Offset" ) ;
  // Attribute to offset
  Name attributeName ;
  ok = ok && ParametersAccessor::get( node, "Attribute", attributeName, _owner ) ;
  _attributeAccessor =
    ok ? _owner->getBaseAttribute< OMK::Type::Transform >( attributeName ) : 0 ;
  ok = ok && _attributeAccessor != 0 ;
  ParametersAccessor::get( node, "IgnoreRotate", _ignoreRotate ) ;
  ParametersAccessor::get( node, "IgnoreScale", _ignoreScale ) ;

  return ok ;
}
//-------------------------------------------------------------------------
void PreOffsetExtension::preComputeParameters()
{
  OMASSERTM( _attributeAccessor,
             debugMsg( this, _owner ) << "Must be initalised !" ) ;

  Transform result( _attributeAccessor->get() ) ;
  Transform offset( _offset.get() ) ;
  Transform value( _attributeAccessor->get() ) ;
  if( offset.isIdentity() )
  {
    result = value ;
  }
  else if( value.isIdentity() )
  {
    result = offset ;
  }
  else
  {
    Wm4::Matrix3f rotate( Wm4::Matrix3f::IDENTITY ) ;
    if( !_ignoreRotate ) 
    {
      result.setRotate( offset.getRotate() * value.getRotate() ) ;
      rotate = offset.getRotate() ;
    }

    if( _ignoreScale )
    {
      result.setTranslate( rotate * value.getTranslate() +
                           offset.getTranslate() ) ;
    }
    else
    {
      if( offset.isUniformScale() )
      {
        result.setTranslate( offset.getUniformScale() *
                             ( rotate * value.getTranslate() ) +
                             offset.getTranslate() ) ;

        if ( value.isUniformScale() )
        {
          result.setUniformScale( offset.getUniformScale() *
                                  value.getUniformScale() ) ;
        }
        else
        {
          result.setScale( offset.getUniformScale() * value.getScale() ) ;
        }
      }
      else
      {
        Wm4::Vector3f v0_translate( rotate * value.getTranslate() ) ;
        Wm4::Vector3f v1_translate( offset.getScale()[0] * v0_translate[0],
                                    offset.getScale()[1] * v0_translate[1],
                                    offset.getScale()[2] * v0_translate[2] ) ;
        result.setTranslate( v1_translate + offset.getTranslate() ) ;

        if ( value.isUniformScale() )
        {
          result.setScale( offset.getScale() * value.getUniformScale() ) ;
        }
        else
        {
          Wm4::Vector3f v0_scale( rotate * value.getScale() ) ;
          Wm4::Vector3f v1_scale( offset.getScale()[0] * v0_scale[0],
                                  offset.getScale()[1] * v0_scale[1],
                                  offset.getScale()[2] * v0_scale[2] ) ;
          result.setScale( v1_scale ) ;
        }
      }
    }
  }

  _attributeAccessor->set( result ) ;
}
//-------------------------------------------------------------------------

//=========================================================================
// PostOffsetExtension
//=========================================================================
REGISTER_EXTENSION_FACTORY( PostOffsetExtension, "PostOffset" ) ;
//-------------------------------------------------------------------------
PostOffsetExtension::PostOffsetExtension( ExtensibleSimulatedObject* owner,
                                  const Name& id,
                                  bool registerExtension )
: PreOffsetExtension( owner, id, registerExtension )
{
}
//-------------------------------------------------------------------------
PostOffsetExtension::~PostOffsetExtension()
{
}
//-------------------------------------------------------------------------

---