D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/RenderSystem/spVideoModeEnumerator.hpp

Go to the documentation of this file.

/*
 * Video mode enumerator header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_VIDEOMODE_RECEIVER_H__
#define __SP_VIDEOMODE_RECEIVER_H__


#include "Base/spStandard.hpp"
#include "Base/spDimensionSize2D.hpp"
#include "Base/spInputOutputString.hpp"


namespace sp
{
namespace video
{


struct SVideoMode
{
    SVideoMode(const dim::size2di &InitResolution = 0, s32 InitColorDepth = 0) :
        Resolution(InitResolution),
        ColorDepth(InitColorDepth)
    {
    }
    SVideoMode(const SVideoMode &Other) :
        Resolution(Other.Resolution),
        ColorDepth(Other.ColorDepth)
    {
    }
    ~SVideoMode()
    {
    }
    
    /* Operators */
    bool operator == (const SVideoMode &Other) const
    {
        return Resolution == Other.Resolution && ColorDepth == Other.ColorDepth;
    }
    
    /* Members */
    dim::size2di Resolution;
    s32 ColorDepth;
};

struct SDisplayDevice
{
    SDisplayDevice()
    {
    }
    SDisplayDevice(const io::stringc &InitVideoController, const io::stringc &InitMonitor) :
        VideoController (InitVideoController),
        Monitor         (InitMonitor        )
    {
    }
    SDisplayDevice(const SDisplayDevice &Other) :
        VideoController (Other.VideoController  ),
        Monitor         (Other.Monitor          )
    {
    }
    ~SDisplayDevice()
    {
    }
    
    /* Members */
    io::stringc VideoController;    
    io::stringc Monitor;            
};


class SP_EXPORT VideoModeEnumerator
{
    
    public:
        
        VideoModeEnumerator();
        ~VideoModeEnumerator();
        
        /* Inline functions */
        
        inline SVideoMode getDesktop() const
        {
            return Desktop_;
        }
        
        inline u32 getVideoModeCount() const
        {
            return VideoModes_.size();
        }
        inline SVideoMode getVideoMode(u32 Index) const
        {
            return Index < VideoModes_.size() ? VideoModes_[Index] : SVideoMode();
        }
        inline const std::vector<SVideoMode>& getVideoModeList() const
        {
            return VideoModes_;
        }
        
        inline u32 getDisplayDeviceCount() const
        {
            return DisplayDevices_.size();
        }
        inline SDisplayDevice getDisplayDevice(u32 Index) const
        {
            return Index < DisplayDevices_.size() ? DisplayDevices_[Index] : SDisplayDevice();
        }
        inline const std::vector<SDisplayDevice>& getDisplayDeviceList() const
        {
            return DisplayDevices_;
        }
        
    private:
        
        /* Members */
        
        SVideoMode Desktop_;
        std::vector<SVideoMode> VideoModes_;
        std::vector<SDisplayDevice> DisplayDevices_;
        
};


} // /namespace video

} // /namespace sp


#endif



// ================================================================================