gpuInfo.h

/* Copyright (c) 2011-2012, Stefan Eilemann <eile@eyescale.ch>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef HWSD_GPUINFO_H
#define HWSD_GPUINFO_H

#include <hwsd/nodeInfo.h>  // base class

#include <climits>
#include <cstring>
#include <iostream>
#include <string>


namespace hwsd
{
    struct GPUInfo : public NodeInfo
    {
        static const unsigned defaultValue = UINT_MAX;

        static const unsigned FLAG_VIRTUALGL = 0x1;

        static const unsigned FLAG_VIRTUALGL_DISPLAY = 0x2;

        GPUInfo()
                : type( 0 ), port( defaultValue ), device( defaultValue )
                , flags( 0 )
            { invalidatePVP(); }

        GPUInfo( const std::string& name )
                : type( 0 ), port( defaultValue ), device( defaultValue )
                , flags( 0 )
            {
                invalidatePVP();
                strncpy( reinterpret_cast< char* >( &type ), name.c_str(), 4 );
            }

        void invalidatePVP()
            {
                pvp[0] = 0;
                pvp[1] = 0;
                pvp[2] = -1;
                pvp[3] = -1;
            }

        bool operator == ( const GPUInfo& rhs ) const
            {
                return ( NodeInfo::operator==( rhs ) && type == rhs.type &&
                         port == rhs.port && device == rhs.device &&
                         pvp[0] == rhs.pvp[0] && pvp[1] == rhs.pvp[1] &&
                         pvp[2] == rhs.pvp[2] && pvp[3] == rhs.pvp[3] );
            }

        bool operator != ( const GPUInfo& rhs ) const
            {
                return !(*this == rhs );
            }

        std::string getName() const
            { return std::string( reinterpret_cast<const char*>( &type ), 4 ); }

        unsigned type;

        unsigned port;

        unsigned device;

        int pvp[4];

        unsigned flags; 
        unsigned unused; 
        char dummy[32]; 
    };

    inline std::ostream& operator << ( std::ostream& os, const GPUInfo& info )
    {
        os << "GPUInfo\n" << static_cast< const NodeInfo& >( info );
        if( !info.getName().empty( ))
            os << "  Type      " << info.getName() << std::endl;
        if( info.port != GPUInfo::defaultValue )
            os << "  Port      " << info.port << std::endl;
        if( info.device != GPUInfo::defaultValue )
            os << "  Device    " << info.device << std::endl;
        if( info.pvp[2] >0 && info.pvp[3] > 0 )
            os << "  Viewport  [" << info.pvp[0] << ' ' << info.pvp[1] << ' '
               << info.pvp[2] << ' ' << info.pvp[3] << ']' << std::endl;
        if( info.flags != 0 )
            os << "  Flags     "
               << (info.flags&GPUInfo::FLAG_VIRTUALGL ? "VirtualGL" : "")
               << (info.flags&GPUInfo::FLAG_VIRTUALGL_DISPLAY ? "Display" : "")
               << std::endl;
        return os;
    }
}

#endif // HWSD_GPUINFO_H