X3DSequencerNode.h

Go to the documentation of this file.

//    Copyright 2004, 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 "X3DChildNode.h"
#include "SFBool.h"
#include "SFFloat.h"
#include "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 H3DAPI_API ValueChanged
                        : public AutoUpdate< TypedField< TheType, 
                                                                                                                                                         Types< SFBool, 
                                                                                                                                                                                  SFBool, 
                                                                                                                                                                                        SFFloat, 
                                                                                                                                                                                        MFFloat, 
                                                                                                                                                                                        KeyValuesIn > > >{
                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() {
                                X3DSequencerNode * sN = 
          static_cast< X3DSequencerNode * >( TheType::getOwner() );

                                bool notMonotonically = false;

                                const typename KeyValuesIn::vector_type &key_value = 
                                        static_cast<  KeyValuesIn * >( TheType::routes_in[4] )->getValue();

                                const vector< H3DFloat > &keys = 
                                        static_cast< MFFloat * >( TheType::routes_in[3] )->getValue();

                                if( keys.empty() ) {
                                        Console(3) << "Warning: The key array is empty in " <<
                                                "X3DSequencerNode ( " << TheType::getName() << 
                                                "). Node will not be used. " << endl;
                                        return;
                                }

                                if( key_value.empty() ) {
                                        Console(3) << "Warning: The keyValue array is empty in " <<
                                                "X3DSequencerNode ( " << TheType::getName() << 
                                                "). Node will not be used. " << endl;
                                        return;
                                }

                                if( keys.size() != key_value.size() ) {
                                        Console(3) << "Warning: The key and keyValue arrays mismatch in " <<
                                                "X3DSequencerNode ( " << TheType::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(3) << "Warning: The key array is not monotonically " <<
                                                "non-decreasing in X3DSequencerNode ( " << TheType::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 = 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);
                                }
                                else if( TheType::routes_in[3] == TheType::event.ptr ) {
                                        if( fractionInitialized ) {
                                                const H3DFloat &setFraction = 
                                                static_cast< SFFloat * >( TheType::routes_in[2] )->getValue( sN -> id );
                                                TheType::value = evaluateValueChanged(key_value, keys, setFraction);
                                        }
                                }
                                else if ( TheType::routes_in[4] == TheType::event.ptr ) {
                                        if( fractionInitialized ) {
                                                const H3DFloat &setFraction = 
                                                static_cast< SFFloat * >( TheType::routes_in[2] )->getValue( sN -> id );
                                                TheType::value = evaluateValueChanged(key_value, keys, setFraction);
                                        }

                                        if( currentPosition > ( H3DInt32 )key_value.size() - 1 ) {
                                                currentPosition = key_value.size() - 1;
                                                TheType::value = key_value[ currentPosition ];
                                        }
                                }
                        }
                };

    X3DSequencerNode(   Inst< SFNode           > _metadata                      = 0,
                                                                                        Inst< SFBool             > _next                        = 0,
                                                                                        Inst< SFBool           > _previous                      = 0,
                                                                                        Inst< SFFloat          > _set_fraction  = 0,
                                                                                        Inst< MFFloat          > _key                           = 0 );
                                                         

    auto_ptr< SFBool >  next;

    auto_ptr< SFBool >  previous;

    auto_ptr< SFFloat >  set_fraction;

    auto_ptr< MFFloat >  key;

    static H3DNodeDatabase database;
        };
}

#endif

---