X3DSequencerNode.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __X3DSEQUENCERNODE_H__
#define __X3DSEQUENCERNODE_H__
 
#include <H3D/X3DChildNode.h>
#include <H3D/SFBool.h>
#include <H3D/SFFloat.h>
#include <H3D/MFFloat.h>
 
namespace H3D {
 
 
  class H3DAPI_API X3DSequencerNode : public X3DChildNode {
  public:
    
    template< class MType > class H3DAPI_API KeyValues : public MType {};
 
    template< class TheType, class KeyValuesIn, class SequencerClass >
      class H3DAPI_API ValueChanged
      : public AutoUpdate< TypedField< TheType, 
                                       Types< SFBool, 
                                              SFBool, 
                                              SFFloat > > > {
    public:
      ValueChanged() { currentPosition = 0; fractionInitialized = false; }
      bool fractionInitialized;
      // The X3D specification never tells from where the next and previous
      // should start. Therefore I choose to start at the beginning
      // by default.
      H3DInt32 currentPosition;
    protected:
      // evaluate the value using set_fraction
      inline  typename TheType::value_type evaluateValueChanged(
        const typename KeyValuesIn::vector_type &key_value, 
        const vector< H3DFloat > &keys, 
        const H3DFloat &setFraction) {
        
        if( setFraction <= keys.front() )
          return key_value.front();
        else if( setFraction >= keys.back() )
          return key_value.back();
        else {
          int i;
          for( i = 0; 
            i < ( H3DInt32 )key_value.size() - 1 &&
            !( setFraction >= keys[i] && setFraction < keys[ i + 1 ] );
          ++i );
          return key_value[i];
        }
      }
      virtual void update() {
        if( TheType::routes_in[0] == TheType::event.ptr ||
            TheType::routes_in[1] == TheType::event.ptr ||
            TheType::routes_in[2] == TheType::event.ptr ) {
        
          SequencerClass * sn = 
            static_cast< SequencerClass * >( TheType::getOwner() );
 
          bool notMonotonically = false;
 
          const typename KeyValuesIn::vector_type &key_value = 
            sn->keyValue->getValue();
 
          const vector< H3DFloat > &keys = sn->key->getValue();
 
          if( keys.empty() ) {
            Console(LogLevel::Warning) << "Warning: The key array is empty in " <<
              "X3DSequencerNode ( " << sn->getName() << 
              " ). Node will not be used. " << endl;
            return;
          }
 
          if( key_value.empty() ) {
            Console(LogLevel::Warning) << "Warning: The keyValue array is empty in " <<
              "X3DSequencerNode ( " << sn->getName() << 
              " ). Node will not be used. " << endl;
            return;
          }
 
          if( keys.size() != key_value.size() ) {
            Console(LogLevel::Warning) << "Warning: The key and keyValue arrays mismatch in " <<
              "X3DSequencerNode ( " << sn->getName() << 
              " ). Node will not be used. " << endl;
            return;
          }
 
          // The keys shall be monotonically non-decreasing,
          // otherwise the results are undefined.
          for( int i = 0; i < (int)keys.size() - 1; ++i ) {
            if( keys[i] > keys[ i + 1 ] )
              notMonotonically = true;
          }
 
          if( notMonotonically ) {
            Console(LogLevel::Warning) << "Warning: The key array is not monotonically " <<
              "non-decreasing in X3DSequencerNode ( " << sn->getName() << 
              " ). Node will not be used. " << endl;
            return;
          }
 
          // next value
          if( TheType::routes_in[0] == TheType::event.ptr ) {
            ++currentPosition;
            if( currentPosition > ( H3DInt32 )key_value.size() - 1 )
              currentPosition = 0;
 
            TheType::value = key_value[ currentPosition ];
          }
          // previous value
          else if( TheType::routes_in[1] == TheType::event.ptr ) {
            --currentPosition;
            if( currentPosition < 0 )
              currentPosition = (H3DInt32) key_value.size() - 1;
 
            TheType::value = key_value[ currentPosition ];
          }
          // if set_fraction is used or anything else changes.
          else if( TheType::routes_in[2] == TheType::event.ptr ) {
            fractionInitialized = true;
            const H3DFloat &setFraction = 
              static_cast< SFFloat * >( TheType::routes_in[2] )->getValue( sn -> id );
            TheType::value = evaluateValueChanged(key_value, keys, setFraction);
          }
        }
      }
    };
#ifdef __BORLANDC__
    template< class TheType, class KeyValuesIn > friend class ValueChanged;
#endif
 
    X3DSequencerNode(  Inst< SFNode           > _metadata      = 0,
                       Inst< SFBool           > _next          = 0,
                       Inst< SFBool           > _previous       = 0,
                       Inst< SFFloat          > _set_fraction  = 0,
                       Inst< MFFloat          > _key           = 0 );
 
    H3DUniquePtr< SFBool >  next;
 
    H3DUniquePtr< SFBool >  previous;
 
    H3DUniquePtr< SFFloat >  set_fraction;
 
    H3DUniquePtr< MFFloat >  key;
 
    static H3DNodeDatabase database;
  };
}
 
#endif