diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/irrlicht-1.8/include/SIrrCreationParameters.h | 296 |
1 files changed, 296 insertions, 0 deletions
diff --git a/libraries/irrlicht-1.8/include/SIrrCreationParameters.h b/libraries/irrlicht-1.8/include/SIrrCreationParameters.h new file mode 100644 index 0000000..cbf558d --- /dev/null +++ b/libraries/irrlicht-1.8/include/SIrrCreationParameters.h | |||
@@ -0,0 +1,296 @@ | |||
1 | // Copyright (C) 2002-2012 Nikolaus Gebhardt | ||
2 | // This file is part of the "Irrlicht Engine". | ||
3 | // For conditions of distribution and use, see copyright notice in irrlicht.h | ||
4 | |||
5 | #ifndef __I_IRRLICHT_CREATION_PARAMETERS_H_INCLUDED__ | ||
6 | #define __I_IRRLICHT_CREATION_PARAMETERS_H_INCLUDED__ | ||
7 | |||
8 | #include "EDriverTypes.h" | ||
9 | #include "EDeviceTypes.h" | ||
10 | #include "dimension2d.h" | ||
11 | #include "ILogger.h" | ||
12 | |||
13 | namespace irr | ||
14 | { | ||
15 | class IEventReceiver; | ||
16 | |||
17 | //! Structure for holding Irrlicht Device creation parameters. | ||
18 | /** This structure is used in the createDeviceEx() function. */ | ||
19 | struct SIrrlichtCreationParameters | ||
20 | { | ||
21 | //! Constructs a SIrrlichtCreationParameters structure with default values. | ||
22 | SIrrlichtCreationParameters() : | ||
23 | DeviceType(EIDT_BEST), | ||
24 | DriverType(video::EDT_BURNINGSVIDEO), | ||
25 | WindowSize(core::dimension2d<u32>(800, 600)), | ||
26 | Bits(16), | ||
27 | ZBufferBits(16), | ||
28 | Fullscreen(false), | ||
29 | Stencilbuffer(false), | ||
30 | Vsync(false), | ||
31 | AntiAlias(0), | ||
32 | HandleSRGB(false), | ||
33 | WithAlphaChannel(false), | ||
34 | Doublebuffer(true), | ||
35 | IgnoreInput(false), | ||
36 | Stereobuffer(false), | ||
37 | HighPrecisionFPU(false), | ||
38 | EventReceiver(0), | ||
39 | WindowId(0), | ||
40 | #ifdef _DEBUG | ||
41 | LoggingLevel(ELL_DEBUG), | ||
42 | #else | ||
43 | LoggingLevel(ELL_INFORMATION), | ||
44 | #endif | ||
45 | DisplayAdapter(0), | ||
46 | DriverMultithreaded(false), | ||
47 | UsePerformanceTimer(true), | ||
48 | SDK_version_do_not_use(IRRLICHT_SDK_VERSION) | ||
49 | { | ||
50 | } | ||
51 | |||
52 | SIrrlichtCreationParameters(const SIrrlichtCreationParameters& other) : | ||
53 | SDK_version_do_not_use(IRRLICHT_SDK_VERSION) | ||
54 | {*this = other;} | ||
55 | |||
56 | SIrrlichtCreationParameters& operator=(const SIrrlichtCreationParameters& other) | ||
57 | { | ||
58 | DeviceType = other.DeviceType; | ||
59 | DriverType = other.DriverType; | ||
60 | WindowSize = other.WindowSize; | ||
61 | Bits = other.Bits; | ||
62 | ZBufferBits = other.ZBufferBits; | ||
63 | Fullscreen = other.Fullscreen; | ||
64 | Stencilbuffer = other.Stencilbuffer; | ||
65 | Vsync = other.Vsync; | ||
66 | AntiAlias = other.AntiAlias; | ||
67 | HandleSRGB = other.HandleSRGB; | ||
68 | WithAlphaChannel = other.WithAlphaChannel; | ||
69 | Doublebuffer = other.Doublebuffer; | ||
70 | IgnoreInput = other.IgnoreInput; | ||
71 | Stereobuffer = other.Stereobuffer; | ||
72 | HighPrecisionFPU = other.HighPrecisionFPU; | ||
73 | EventReceiver = other.EventReceiver; | ||
74 | WindowId = other.WindowId; | ||
75 | LoggingLevel = other.LoggingLevel; | ||
76 | DriverMultithreaded = other.DriverMultithreaded; | ||
77 | DisplayAdapter = other.DisplayAdapter; | ||
78 | UsePerformanceTimer = other.UsePerformanceTimer; | ||
79 | return *this; | ||
80 | } | ||
81 | |||
82 | //! Type of the device. | ||
83 | /** This setting decides the windowing system used by the device, most device types are native | ||
84 | to a specific operating system and so may not be available. | ||
85 | EIDT_WIN32 is only available on Windows desktops, | ||
86 | EIDT_WINCE is only available on Windows mobile devices, | ||
87 | EIDT_COCOA is only available on Mac OSX, | ||
88 | EIDT_X11 is available on Linux, Solaris, BSD and other operating systems which use X11, | ||
89 | EIDT_SDL is available on most systems if compiled in, | ||
90 | EIDT_CONSOLE is usually available but can only render to text, | ||
91 | EIDT_BEST will select the best available device for your operating system. | ||
92 | Default: EIDT_BEST. */ | ||
93 | E_DEVICE_TYPE DeviceType; | ||
94 | |||
95 | //! Type of video driver used to render graphics. | ||
96 | /** This can currently be video::EDT_NULL, video::EDT_SOFTWARE, | ||
97 | video::EDT_BURNINGSVIDEO, video::EDT_DIRECT3D8, | ||
98 | video::EDT_DIRECT3D9, and video::EDT_OPENGL. | ||
99 | Default: Software. */ | ||
100 | video::E_DRIVER_TYPE DriverType; | ||
101 | |||
102 | //! Size of the window or the video mode in fullscreen mode. Default: 800x600 | ||
103 | core::dimension2d<u32> WindowSize; | ||
104 | |||
105 | //! Minimum Bits per pixel of the color buffer in fullscreen mode. Ignored if windowed mode. Default: 16. | ||
106 | u8 Bits; | ||
107 | |||
108 | //! Minimum Bits per pixel of the depth buffer. Default: 16. | ||
109 | u8 ZBufferBits; | ||
110 | |||
111 | //! Should be set to true if the device should run in fullscreen. | ||
112 | /** Otherwise the device runs in windowed mode. Default: false. */ | ||
113 | bool Fullscreen; | ||
114 | |||
115 | //! Specifies if the stencil buffer should be enabled. | ||
116 | /** Set this to true, if you want the engine be able to draw | ||
117 | stencil buffer shadows. Note that not all drivers are able to | ||
118 | use the stencil buffer, hence it can be ignored during device | ||
119 | creation. Without the stencil buffer no shadows will be drawn. | ||
120 | Default: false. */ | ||
121 | bool Stencilbuffer; | ||
122 | |||
123 | //! Specifies vertical syncronisation. | ||
124 | /** If set to true, the driver will wait for the vertical | ||
125 | retrace period, otherwise not. May be silently ignored. | ||
126 | Default: false */ | ||
127 | bool Vsync; | ||
128 | |||
129 | //! Specifies if the device should use fullscreen anti aliasing | ||
130 | /** Makes sharp/pixelated edges softer, but requires more | ||
131 | performance. Also, 2D elements might look blurred with this | ||
132 | switched on. The resulting rendering quality also depends on | ||
133 | the hardware and driver you are using, your program might look | ||
134 | different on different hardware with this. So if you are | ||
135 | writing a game/application with AntiAlias switched on, it would | ||
136 | be a good idea to make it possible to switch this option off | ||
137 | again by the user. | ||
138 | The value is the maximal antialiasing factor requested for | ||
139 | the device. The cretion method will automatically try smaller | ||
140 | values if no window can be created with the given value. | ||
141 | Value one is usually the same as 0 (disabled), but might be a | ||
142 | special value on some platforms. On D3D devices it maps to | ||
143 | NONMASKABLE. | ||
144 | Default value: 0 - disabled */ | ||
145 | u8 AntiAlias; | ||
146 | |||
147 | //! Flag to enable proper sRGB and linear color handling | ||
148 | /** In most situations, it is desireable to have the color handling in | ||
149 | non-linear sRGB color space, and only do the intermediate color | ||
150 | calculations in linear RGB space. If this flag is enabled, the device and | ||
151 | driver try to assure that all color input and output are color corrected | ||
152 | and only the internal color representation is linear. This means, that | ||
153 | the color output is properly gamma-adjusted to provide the brighter | ||
154 | colors for monitor display. And that blending and lighting give a more | ||
155 | natural look, due to proper conversion from non-linear colors into linear | ||
156 | color space for blend operations. If this flag is enabled, all texture colors | ||
157 | (which are usually in sRGB space) are correctly displayed. However vertex colors | ||
158 | and other explicitly set values have to be manually encoded in linear color space. | ||
159 | Default value: false. */ | ||
160 | bool HandleSRGB; | ||
161 | |||
162 | //! Whether the main framebuffer uses an alpha channel. | ||
163 | /** In some situations it might be desireable to get a color | ||
164 | buffer with an alpha channel, e.g. when rendering into a | ||
165 | transparent window or overlay. If this flag is set the device | ||
166 | tries to create a framebuffer with alpha channel. | ||
167 | If this flag is set, only color buffers with alpha channel | ||
168 | are considered. Otherwise, it depends on the actual hardware | ||
169 | if the colorbuffer has an alpha channel or not. | ||
170 | Default value: false */ | ||
171 | bool WithAlphaChannel; | ||
172 | |||
173 | //! Whether the main framebuffer uses doublebuffering. | ||
174 | /** This should be usually enabled, in order to avoid render | ||
175 | artifacts on the visible framebuffer. However, it might be | ||
176 | useful to use only one buffer on very small devices. If no | ||
177 | doublebuffering is available, the drivers will fall back to | ||
178 | single buffers. Default value: true */ | ||
179 | bool Doublebuffer; | ||
180 | |||
181 | //! Specifies if the device should ignore input events | ||
182 | /** This is only relevant when using external I/O handlers. | ||
183 | External windows need to take care of this themselves. | ||
184 | Currently only supported by X11. | ||
185 | Default value: false */ | ||
186 | bool IgnoreInput; | ||
187 | |||
188 | //! Specifies if the device should use stereo buffers | ||
189 | /** Some high-end gfx cards support two framebuffers for direct | ||
190 | support of stereoscopic output devices. If this flag is set the | ||
191 | device tries to create a stereo context. | ||
192 | Currently only supported by OpenGL. | ||
193 | Default value: false */ | ||
194 | bool Stereobuffer; | ||
195 | |||
196 | //! Specifies if the device should use high precision FPU setting | ||
197 | /** This is only relevant for DirectX Devices, which switch to | ||
198 | low FPU precision by default for performance reasons. However, | ||
199 | this may lead to problems with the other computations of the | ||
200 | application. In this case setting this flag to true should help | ||
201 | - on the expense of performance loss, though. | ||
202 | Default value: false */ | ||
203 | bool HighPrecisionFPU; | ||
204 | |||
205 | //! A user created event receiver. | ||
206 | IEventReceiver* EventReceiver; | ||
207 | |||
208 | //! Window Id. | ||
209 | /** If this is set to a value other than 0, the Irrlicht Engine | ||
210 | will be created in an already existing window. For windows, set | ||
211 | this to the HWND of the window you want. The windowSize and | ||
212 | FullScreen options will be ignored when using the WindowId | ||
213 | parameter. Default this is set to 0. | ||
214 | To make Irrlicht run inside the custom window, you still will | ||
215 | have to draw Irrlicht on your own. You can use this loop, as | ||
216 | usual: | ||
217 | \code | ||
218 | while (device->run()) | ||
219 | { | ||
220 | driver->beginScene(true, true, 0); | ||
221 | smgr->drawAll(); | ||
222 | driver->endScene(); | ||
223 | } | ||
224 | \endcode | ||
225 | Instead of this, you can also simply use your own message loop | ||
226 | using GetMessage, DispatchMessage and whatever. Calling | ||
227 | IrrlichtDevice::run() will cause Irrlicht to dispatch messages | ||
228 | internally too. You need not call Device->run() if you want to | ||
229 | do your own message dispatching loop, but Irrlicht will not be | ||
230 | able to fetch user input then and you have to do it on your own | ||
231 | using the window messages, DirectInput, or whatever. Also, | ||
232 | you'll have to increment the Irrlicht timer. | ||
233 | An alternative, own message dispatching loop without | ||
234 | device->run() would look like this: | ||
235 | \code | ||
236 | MSG msg; | ||
237 | while (true) | ||
238 | { | ||
239 | if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) | ||
240 | { | ||
241 | TranslateMessage(&msg); | ||
242 | DispatchMessage(&msg); | ||
243 | |||
244 | if (msg.message == WM_QUIT) | ||
245 | break; | ||
246 | } | ||
247 | |||
248 | // increase virtual timer time | ||
249 | device->getTimer()->tick(); | ||
250 | |||
251 | // draw engine picture | ||
252 | driver->beginScene(true, true, 0); | ||
253 | smgr->drawAll(); | ||
254 | driver->endScene(); | ||
255 | } | ||
256 | \endcode | ||
257 | However, there is no need to draw the picture this often. Just | ||
258 | do it how you like. */ | ||
259 | void* WindowId; | ||
260 | |||
261 | //! Specifies the logging level used in the logging interface. | ||
262 | /** The default value is ELL_INFORMATION. You can access the ILogger interface | ||
263 | later on from the IrrlichtDevice with getLogger() and set another level. | ||
264 | But if you need more or less logging information already from device creation, | ||
265 | then you have to change it here. | ||
266 | */ | ||
267 | ELOG_LEVEL LoggingLevel; | ||
268 | |||
269 | //! Allows to select which graphic card is used for rendering when more than one card is in the system. | ||
270 | /** So far only supported on D3D */ | ||
271 | u32 DisplayAdapter; | ||
272 | |||
273 | //! Create the driver multithreaded. | ||
274 | /** Default is false. Enabling this can slow down your application. | ||
275 | Note that this does _not_ make Irrlicht threadsafe, but only the underlying driver-API for the graphiccard. | ||
276 | So far only supported on D3D. */ | ||
277 | bool DriverMultithreaded; | ||
278 | |||
279 | //! Enables use of high performance timers on Windows platform. | ||
280 | /** When performance timers are not used, standard GetTickCount() | ||
281 | is used instead which usually has worse resolution, but also less | ||
282 | problems with speed stepping and other techniques. | ||
283 | */ | ||
284 | bool UsePerformanceTimer; | ||
285 | |||
286 | //! Don't use or change this parameter. | ||
287 | /** Always set it to IRRLICHT_SDK_VERSION, which is done by default. | ||
288 | This is needed for sdk version checks. */ | ||
289 | const c8* const SDK_version_do_not_use; | ||
290 | }; | ||
291 | |||
292 | |||
293 | } // end namespace irr | ||
294 | |||
295 | #endif | ||
296 | |||