SIrrCreationParameters.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in jimcpp/jimcpp.hpp
 
#ifndef JPP_JIMCPP_CREATION_PARAMETERS_HPP_INCLUDED
#define JPP_JIMCPP_CREATION_PARAMETERS_HPP_INCLUDED
 
#include <jimcpp/core/engine/EDriverTypes.hpp>
#include <jimcpp/core/engine/EDeviceTypes.hpp>
#include <jimcpp/core/engine/dimension2d.hpp>
#include <jimcpp/core/engine/ILogger.hpp>
#include <jimcpp/core/engine/position2d.hpp>
 
namespace jpp
{
    class IEventReceiver;
 
 
    class SJimcppCreationParameters
    {
    public:
 
        E_DEVICE_TYPE DeviceType;
 
 
        video::E_DRIVER_TYPE DriverType;
 
        core::dimension2d<u32> WindowSize;
 
        core::position2di WindowPosition;
 
        u8 Bits;
 
        u8 ZBufferBits;
 
 
        bool Fullscreen;
 
 
        u8 WindowResizable;
 
 
        bool Stencilbuffer;
 
 
        bool Vsync;
 
 
        u8 AntiAlias;
 
 
        bool HandleSRGB;
 
 
        bool WithAlphaChannel;
 
 
        bool Doublebuffer;
 
 
        bool IgnoreInput;
 
 
        bool Stereobuffer;
 
 
        bool HighPrecisionFPU;
 
        IEventReceiver* EventReceiver;
 
 
        void* WindowId;
 
 
        ELOG_LEVEL LoggingLevel;
 
 
        u32 DisplayAdapter;
 
 
        bool DriverMultithreaded;
 
 
        bool UsePerformanceTimer;
 
 
        const c8* const SDK_version_do_not_use;
    public:
        SJimcppCreationParameters() :
            DeviceType(EIDT_BEST),
            DriverType(video::EDT_BURNINGSVIDEO),
            WindowSize(core::dimension2d<u32>(800, 600)),
            WindowPosition(core::position2di(-1,-1)),
            Bits(32),
            ZBufferBits(24),
            Fullscreen(false),
            WindowResizable(2),
            Stencilbuffer(true),
            Vsync(false),
            AntiAlias(0),
            HandleSRGB(false),
            WithAlphaChannel(false),
            Doublebuffer(true),
            IgnoreInput(false),
            Stereobuffer(false),
            HighPrecisionFPU(false),
            EventReceiver(0),
            WindowId(0),
#ifdef _DEBUG
            LoggingLevel(ELL_DEBUG),
#else
            LoggingLevel(ELL_INFORMATION),
#endif
            DisplayAdapter(0),
            DriverMultithreaded(false),
            UsePerformanceTimer(true),
            SDK_version_do_not_use(JIMCPP_SDK_VERSION)
        {
        }
 
        SJimcppCreationParameters(const SJimcppCreationParameters& other) :
            SDK_version_do_not_use(JIMCPP_SDK_VERSION)
        {*this = other;}
 
        SJimcppCreationParameters& operator=(const SJimcppCreationParameters& other)
        {
            DeviceType = other.DeviceType;
            DriverType = other.DriverType;
            WindowSize = other.WindowSize;
            WindowPosition = other.WindowPosition;
            Bits = other.Bits;
            ZBufferBits = other.ZBufferBits;
            Fullscreen = other.Fullscreen;
            WindowResizable = other.WindowResizable;
            Stencilbuffer = other.Stencilbuffer;
            Vsync = other.Vsync;
            AntiAlias = other.AntiAlias;
            HandleSRGB = other.HandleSRGB;
            WithAlphaChannel = other.WithAlphaChannel;
            Doublebuffer = other.Doublebuffer;
            IgnoreInput = other.IgnoreInput;
            Stereobuffer = other.Stereobuffer;
            HighPrecisionFPU = other.HighPrecisionFPU;
            EventReceiver = other.EventReceiver;
            WindowId = other.WindowId;
            LoggingLevel = other.LoggingLevel;
            DisplayAdapter = other.DisplayAdapter;
            DriverMultithreaded = other.DriverMultithreaded;
            UsePerformanceTimer = other.UsePerformanceTimer;
            return *this;
        }
    }; // class SJimcppCreationParameters
 
} // end namespace jpp
 
#endif