SIrrCreationParameters.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __I_IRRLICHT_CREATION_PARAMETERS_H_INCLUDED__
#define __I_IRRLICHT_CREATION_PARAMETERS_H_INCLUDED__

#include "EDriverTypes.h"
#include "EDeviceTypes.h"
#include "dimension2d.h"
#include "ILogger.h"
#include "position2d.h"
#include "path.h"
#include "IrrCompileConfig.h"

namespace irr
{
        class IEventReceiver;


        struct SIrrlichtCreationParameters
        {
                SIrrlichtCreationParameters() :
                        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(false),
                        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(IRRLICHT_SDK_VERSION),
                        PrivateData(0),
#if defined(_IRR_COMPILE_WITH_IOS_DEVICE_) || defined(_IRR_ANDROID_PLATFORM_) || defined(_IRR_EMSCRIPTEN_PLATFORM_)
                        OGLES2ShaderPath("media/Shaders/")
#else
                        OGLES2ShaderPath("../../media/Shaders/")
#endif
                {
                }

                SIrrlichtCreationParameters(const SIrrlichtCreationParameters& other) :
                        SDK_version_do_not_use(IRRLICHT_SDK_VERSION)
                {*this = other;}

                SIrrlichtCreationParameters& operator=(const SIrrlichtCreationParameters& 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;
                        PrivateData = other.PrivateData;
                        OGLES2ShaderPath = other.OGLES2ShaderPath;
                        return *this;
                }


                E_DEVICE_TYPE DeviceType;


                video::E_DRIVER_TYPE DriverType;

                core::dimension2d<u32> WindowSize;

                core::position2di WindowPosition;

                u8 Bits;

                u8 ZBufferBits;


                bool Fullscreen;


                bool 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;


                void *PrivateData;


                irr::io::path OGLES2ShaderPath;
        };


} // end namespace irr

#endif