gls_animation_parser.cpp

Go to the documentation of this file.

#include "gls_animation.h"
#include "tinyxml2.h"
#ifdef GLS_ANIMATION_ENABLE_ZIP_LOADING
#    include "unzip.h"
#endif

#include <algorithm>
#include <fstream>
#include <sstream>

namespace disti
{
    namespace
    {
        // This list of strings represents the strings we expect to find in the file to be parsed.
        // We use std::string where explicit comparisons are expected and char* where not.
        const std::string s_expectedVersion = "1.0";

        const char* const s_animationCollectionTag = "AnimationSequence";
        const std::string s_animationPropertyTag   = "AnimationProperty";

        const char* const s_nameTag = "name";
        const char* const s_typeTag = "type";

        const std::string s_floatTypeTag  = "float";
        const std::string s_vec3fTypeTag  = "vec3f";
        const std::string s_vec4fTypeTag  = "vec4f";
        const std::string s_colorTypeTag  = "color";
        const std::string s_stringTypeTag = "string";

        const char s_typeSeparator = ':';

        const std::string s_keyTag   = "Key";
        const char* const s_timeTag  = "t";
        const char* const s_valueTag = "v";

        // For non-string values, parse the value.
        template<class Value>
        Value Destringify( const std::string& str, typename Detail::enable_if< !Detail::is_same< Value, std::string >::value >::type* = 0 )
        {
            std::istringstream iss( str );
            Value value;
            iss >> value;
            return value;
        }

        // For std::string, return the whole string without parsing.
        template<class Value>
        Value Destringify( const std::string& str, typename Detail::enable_if< Detail::is_same< Value, std::string >::value >::type* = 0 )
        {
            return str;
        }

        template<class Value>
        typename GlsKeyframeCurve<Value>::PtrConst ParseKeyframes( tinyxml2::XMLElement* const element, const std::string& interpType, const char* const name )
        {
            typename GlsKeyframeInterpolator<Value>::PtrConst interpolator( CreateInterpolator<Value>( interpType ) );
            if( !interpolator )
            {
                return typename GlsKeyframeCurve<Value>::PtrConst();
            }

            typename GlsKeyframeCurve<Value>::Ptr curve( new GlsKeyframeCurve<Value>( interpolator ) );

            for( tinyxml2::XMLElement* elemChild = element->FirstChildElement(); elemChild != NULL; elemChild = elemChild->NextSiblingElement() )
            {
                if( s_keyTag == elemChild->Value() )
                {
                    double key;
                    if( const char* time = elemChild->Attribute( s_timeTag ) )
                    {
                        key = std::atof( time );
                    }
                    else
                    {
                        std::cerr << "LoadAnimationScript(): No key found for frame in  '" << name << "'. Ignoring.\n";
                        continue;
                    }

                    std::string valueStr;
                    if( const char* value = elemChild->Attribute( s_valueTag ) )
                    {
                        valueStr = value;
                    }
                    else if( const char* text = elemChild->GetText() )
                    {
                        valueStr = text;
                    }
                    else
                    {
                        std::cerr << "LoadAnimationScript(): Key '" << key << "' did not have a value. Ignoring.\n";
                        continue;
                    }

                    curve->AddKeyframe( key, Destringify<Value>( valueStr ) );
                }
            }
            return curve;
        }

        GlsAnimation::Ptr LoadAnimation( const std::vector<char>& file, const std::string& name )
        {
            tinyxml2::XMLDocument doc;
            if( doc.Parse( const_cast<char*>( &file[0] ), file.size()) != tinyxml2::XML_NO_ERROR )
            {
                std::cerr << "LoadAnimation(): Unable to parse script file " << name << ". (Bad format?)\n";
                return GlsAnimation::Ptr();
            }

            tinyxml2::XMLNode* frames = doc.FirstChildElement( s_animationCollectionTag );

            if( frames == 0 )
            {
                std::cerr << "LoadAnimation(): " << s_animationCollectionTag << " tag not found in " << name << std::endl;
                return GlsAnimation::Ptr();
            }

            // Validate the file version
            tinyxml2::XMLElement* topElem = frames->ToElement();
            DistiAssert( topElem );
            const char* version = topElem->Attribute( "version" );
            if( !version || version != s_expectedVersion )
            {
                std::cerr << "LoadAnimation(): Unknown version number (found=" << (version ? version : "no version") 
                    << ", expected=" << s_expectedVersion << ")\n";
                return GlsAnimation::Ptr();
            }

            // Parse the file
            GlsAnimationCollection::Ptr animationSeq( new GlsAnimationCollection( name ) );
            for( tinyxml2::XMLElement* child = frames->FirstChildElement(); child != NULL; child = child->NextSiblingElement())
            {
                const char* childValue = child->Value();
                if( childValue && s_animationPropertyTag == childValue )
                {
                    const char* animationName = child->Attribute( s_nameTag );
                    const char* rawType       = child->Attribute( s_typeTag );
                    if( !rawType || !animationName )
                    {
                        std::cerr << "LoadAnimation(): Name and/or type tags not set(Name=" << (animationName ? animationName : "Not Set") 
                            << ", type=" << (rawType ? rawType : "Not Set") << ")\n";
                        continue;
                    }
                    std::string baseType     = rawType;
                    const std::size_t sepPos = baseType.find( s_typeSeparator );
                    std::string interpType   = sepPos != std::string::npos ? baseType.substr( sepPos + 1 ) : std::string();
                    if( !interpType.empty() )
                    {
                        baseType = baseType.substr( 0, sepPos );
                    }

                    if( s_floatTypeTag == baseType )
                    {
                        const GlsKeyframeCurve<double>::PtrConst curve = ( ParseKeyframes<double>( child, interpType, animationName ) );
                        if( curve && curve->GetKeyframeCount() > 0 )
                        {
                            animationSeq->Add( new GlsKeyframeAnimation( name, animationName, curve ) );
                        }
                    }
                    else if( s_vec3fTypeTag == baseType )
                    {
                        const GlsKeyframeCurve<Vector>::PtrConst curve = ParseKeyframes<Vector>( child, interpType, animationName );
                        if( curve && curve->GetKeyframeCount() > 0 )
                        {
                            animationSeq->Add( new GlsKeyframeAnimation( name, animationName, curve ) );
                        }
                    }
                    else if( s_vec4fTypeTag == baseType )
                    {
                        const GlsKeyframeCurve<GlsQuaternionD>::PtrConst curve = ParseKeyframes<GlsQuaternionD>( child, interpType, animationName );
                        if( curve && curve->GetKeyframeCount() > 0 )
                        {
                            animationSeq->Add( new GlsKeyframeAnimation( name, animationName, curve ) );
                        }
                    }
                    else if( s_colorTypeTag == baseType )
                    {
                        const GlsKeyframeCurve<glsColor>::PtrConst curve = ParseKeyframes<glsColor>( child, interpType, animationName );
                        if( curve && curve->GetKeyframeCount() > 0 )
                        {
                            animationSeq->Add( new GlsKeyframeAnimation( name, animationName, curve ) );
                        }
                    }
                    else if( s_stringTypeTag == baseType )
                    {
                        if( !interpType.empty() && interpType != g_gatedInterpTag )
                        {
                            std::cerr << "LoadAnimation(): Forcing string to gated interpolation: " << name << " of type " << rawType << std::endl;
                        }
                        const GlsKeyframeCurve<std::string>::PtrConst curve = ParseKeyframes<std::string>( child, g_gatedInterpTag, animationName );
                        if( curve && curve->GetKeyframeCount() > 0 )
                        {
                            animationSeq->Add( new GlsKeyframeAnimation( name, animationName, curve ) );
                        }
                    }
                    else
                    {
                        std::cerr << "LoadAnimation(): Unknown type tag found (type=" << baseType.c_str() 
                            << ", name=" << animationName << "). Ignoring.\n";
                    }
                }
                else
                {
                    std::cerr << "LoadAnimation(): Unknown property tag found (property=" << (childValue ? childValue : "N/A") 
                        << ", expected=" << s_animationPropertyTag << "). Ignoring.\n";
                }
            } 
            if( animationSeq->GetAnimationCount() == 0 )
            {
                std::cerr << "LoadAnimation(): No keys found in file " << name << std::endl;
                return GlsAnimation::Ptr();
            }
            return animationSeq;
        }
    }

#ifdef GLS_ANIMATION_ENABLE_ZIP_LOADING    
    std::vector< GlsAnimation::Ptr >  LoadAnimationZip( const std::string& filename )
    {
        std::vector< GlsAnimation::Ptr > animations;

        
        unzFile zipFile  = unzOpen(filename.c_str());
        
        if (unzGoToFirstFile(zipFile) != UNZ_OK)
        {
            std::cerr << "LoadAnimationZip(): Unable to open file " << filename << std::endl;
            return animations;
        }
        
        const unsigned int bufSize(4096);
        std::vector<char> buf(bufSize);
        unz_file_info file_info;
        do
        {

            if( unzGetCurrentFileInfo(zipFile, &file_info, &buf[0], bufSize - 1, NULL,0, NULL,0) != UNZ_OK )
            {
                std::cerr << "LoadAnimationZip(): Error getting file info from file in " << filename << std::endl;
                continue;
            }
            
            std::string zippedFilename = &buf[0];

            std::string extension = zippedFilename.substr( zippedFilename.rfind('.') + 1 );
            std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
            if (extension == "zip")
            {
                std::cerr << "LoadAnimationZip(): File '" << filename << "' contains a zip file.  Nested zip files are not supported. Ignoring.\n";
                continue;
            }

            const uLong size = file_info.uncompressed_size;
            
            if( unzOpenCurrentFile(zipFile) != UNZ_OK )
            {
                std::cerr << "LoadAnimationZip(): Error opening file " << zippedFilename <<  " in file " << filename << std::endl;
                continue;
            }
            
            std::vector<char> data(size);

            if( unzReadCurrentFile(zipFile,&data[0],size) != static_cast<int>( size ) )
            {
                std::cerr << "LoadAnimationZip(): Error reading from file " << zippedFilename <<  " in file " << filename << std::endl;
                continue;
            }
            
            if( GlsAnimation::Ptr anim = LoadAnimation( data, zippedFilename ) )
            {
                animations.push_back( anim );
            }


        } while(unzGoToNextFile(zipFile) == UNZ_OK);

        return animations;
    }
#endif

    GlsAnimation::Ptr LoadAnimationScript( const std::string& filename )
    {
        // Load the document
        std::ifstream readIn( filename.c_str(), std::ios_base::ate );

        if( !readIn )
        {
            std::cerr << "LoadAnimationScript(): Unable to load script file " << filename << std::endl;
            return GlsAnimation::Ptr();
        }

        std::streampos  size = readIn.tellg();
        readIn.seekg( 0 );

        if( !readIn || size == static_cast<std::streampos>(-1) ) // tellg returns -1 on an error
        {
            std::cerr << "LoadAnimationScript(): Error reading from file " << filename << std::endl;
            return GlsAnimation::Ptr();
        }

        std::vector<char> data( static_cast<unsigned int>( size ) );
        readIn.read( &data[0], size );

        return  LoadAnimation( data, filename );
    }
}