PageRenderTime 203ms CodeModel.GetById 91ms app.highlight 9ms RepoModel.GetById 91ms app.codeStats 1ms

/Dlls/Delta.Engine.xml

#
XML | 1204 lines | 1204 code | 0 blank | 0 comment | 0 complexity | 53ba3d2d66e4cac9bc74eefa6dc4e06c MD5 | raw file

Large files files are truncated, but you can click here to view the full file

  1<?xml version="1.0" encoding="utf-8"?>
  2<doc>
  3  <assembly>
  4    <name>Delta.Engine</name>
  5  </assembly>
  6  <members>
  7    <member name="T:Delta.Engine.SystemInformation">
  8      <summary>
  9            Base system information class that is implemented in each platform
 10            module. It provides system information that does not change over the
 11            course of a running application or does not need updates. Some method
 12            might take some time, for example determining the cpu speed can take
 13            a few ms, so only call it when really needed. Access is provided through
 14            Application.Information, which is only initialized when first used. The
 15            Delta Engine itself very rarely needs this class, mostly only to make
 16            some cpu speed checks and getting MaxVertexShader and MaxPixelShader.
 17            </summary>
 18    </member>
 19    <member name="M:Delta.Engine.SystemInformation.InvokeLowMemory">
 20      <summary>
 21            Helper method to invoke the low memory event for the native
 22            implementations.
 23            </summary>
 24    </member>
 25    <member name="M:Delta.Engine.SystemInformation.InvokeLowBattery">
 26      <summary>
 27            Helper method to invoke the low battery event for the native
 28            implementations.
 29            </summary>
 30    </member>
 31    <member name="M:Delta.Engine.SystemInformation.InvokeAppPause">
 32      <summary>
 33            Helper method to invoke the app pause event for the native
 34            implementations.
 35            </summary>
 36    </member>
 37    <member name="M:Delta.Engine.SystemInformation.InvokeAppResume">
 38      <summary>
 39            Helper method to invoke the app resume event for the native
 40            implementations.
 41            </summary>
 42    </member>
 43    <member name="E:Delta.Engine.SystemInformation.OnLowMemory">
 44      <summary>
 45            Delegate for low memory cases on the current platform.
 46            Will be raised by the MonoDroidActivity for example.
 47            </summary>
 48    </member>
 49    <member name="E:Delta.Engine.SystemInformation.OnLowBattery">
 50      <summary>
 51            Delegate for low battery cases on the current platform.
 52            Will be raised by the MonoDroidActivity for example.
 53            </summary>
 54    </member>
 55    <member name="E:Delta.Engine.SystemInformation.OnAppPause">
 56      <summary>
 57            Delegate which is thrown once the app is paused or sent to the
 58            background. This can be the home button on Android, the Back button
 59            on WP7 or iOS.
 60            <para />
 61            For example on android this needs to dispose all opengl contents and
 62            destroy the graphics context, which will be recreated in OnAppResume.
 63            <para />
 64            This is also a good place to pause the GameTime and pause the actual
 65            game if needed.
 66            </summary>
 67    </member>
 68    <member name="E:Delta.Engine.SystemInformation.OnAppResume">
 69      <summary>
 70            Delegate which is thrown once the app is resumed after a pause.
 71            <para />
 72            For example on android this needs to recreate the graphics context and
 73            start the Run loop of the GameView once again.
 74            </summary>
 75    </member>
 76    <member name="P:Delta.Engine.SystemInformation.MachineName">
 77      <summary>
 78            Machine name for this system. On windows this is the Netbios name for
 79            this PC, which is the network computer name. On other platforms this
 80            will return some details about the platform (device name). In any case
 81            this property is not used by the engine, but still might be useful to
 82            link this name up to log or content server client names, which use it!
 83            </summary>
 84    </member>
 85    <member name="P:Delta.Engine.SystemInformation.IsMobileDevice">
 86      <summary>
 87            Is this device a mobile device? Memory consumption and power usage
 88            should be optimized. In release builds the framerate will be bound
 89            to the maximum capabilities (there is no sense wasting more cpu time
 90            except for profiling and debugging). Mobile devices might also want
 91            different UI. Make sure to also check the IsTablet property. Common
 92            resolutions for mobile devices are 480x320, 800x480 and more for newer
 93            devices, see Application.Window.Size for the actual current resolution.
 94            </summary>
 95      <value>
 96        <c>true</c> if this device is a mobile device (phone or table);
 97            otherwise, <c>false</c>.
 98            </value>
 99    </member>
100    <member name="P:Delta.Engine.SystemInformation.IsTablet">
101      <summary>
102            Is this device a tablet device (like an iPad or Android tablet). If
103            this is set the IsMobileDevice setting is also true since tablets are
104            also pretty mobile and need to be aware of their power usage. This
105            property is most commonly used to check if we need a different UI or
106            bigger effects or sometimes different optimizations or shaders. The
107            best example is probably to have different in game ui for tablet
108            devices just because there is more physical screen space. This means
109            even if a mobile phone has the same resolution as a tablet device,
110            a UI scene designed for a tablet device with lots of buttons might
111            not be a good idea on a small phone with just 3.5 inches instead of
112            9.7 inches for a tablet device. Usually the SceneEditor handles all
113            this for you and allows designers to target specific device groups.
114            </summary>
115      <value>
116        <c>true</c> if this device is a Tablet; otherwise, <c>false</c>.
117            </value>
118    </member>
119    <member name="P:Delta.Engine.SystemInformation.IsConsole">
120      <summary>
121            This property is used to mark console devices (Xbox 360, PS3, Wii,
122            or even PSP, N3DS or other devices that might be mobile too).
123            </summary>
124      <value>
125        <c>true</c> if this device is a Console; otherwise, <c>false</c>.
126            </value>
127    </member>
128    <member name="P:Delta.Engine.SystemInformation.MaxResolution">
129      <summary>
130            This property returns for every platform the maximum resolution that
131            is possible or makes sense (usually limited by the device display or
132            GPU). Normally this should be the full screen resolution, but on some
133            systems we might want a lower resolution for better performance or on
134            Windows we can use windowed mode with a smaller resolution for testing.
135            </summary>
136    </member>
137    <member name="P:Delta.Engine.SystemInformation.Language">
138      <summary>
139            Grab the current language of the running system. Currently only checks
140            for the 5 languages: German, Spanish, French, Italian and English
141            (which is always the fallback).
142            </summary>
143    </member>
144    <member name="P:Delta.Engine.SystemInformation.Username">
145      <summary>
146            Username of the current platform. E.g. in Windows this is the
147            user account that is currently logged in. On other platforms this
148            feature might not be supported and then just "Player" is returned.
149            </summary>
150    </member>
151    <member name="P:Delta.Engine.SystemInformation.CpuName">
152      <summary>
153            Gets the name of the CPU of the currently used device. Most devices
154            only have a certain CPU, but devices that come from many different
155            manufacturers have very different CPUs and sometimes it can be useful
156            to do some quick compares which CPU is there (e.g. on Windows you
157            have many different CPUs from AMD or Intel, on Android there are many
158            different manufacturers and CPU/GPU combinations).
159            </summary>
160    </member>
161    <member name="P:Delta.Engine.SystemInformation.GpuName">
162      <summary>
163            Gets the name of the GPU of the currently used device. Most devices
164            only have a certain GPU (especially mobile and console devices have
165            mostly the same GPU, Xbox 360 is always the same, etc.).
166            </summary>
167    </member>
168    <member name="P:Delta.Engine.SystemInformation.CpuSpeed">
169      <summary>
170            Cpu speed for this device in Mhz. Not really comparable since each
171            platform has different characteristics and even on the same platforms
172            the same CPU speed in Mhz might be much slower or faster depending
173            on the architecture and chip manufacturer (AMD vs intel, recent or
174            older generation, etc.). Should also be used together with CoreCount!
175            This cpu speed is just the speed of the first core, which is very
176            rarely different from the other cores and the first core is usually
177            the important one anyway for game logic.
178            </summary>
179    </member>
180    <member name="P:Delta.Engine.SystemInformation.CpuUsage">
181      <summary>
182            The usage of the cpu's in percent 0-1 stored as a float.
183            </summary>
184    </member>
185    <member name="P:Delta.Engine.SystemInformation.CoreCount">
186      <summary>
187            Returns the number of the cores in the CPU or if there is multiple
188            CPUs how many cores are available together. This includes hyperthreaded
189            cores as well (so an i7 has 8 hyperthreaded cores). Most mobile devices
190            only will have one core, but some already have 2 (iPad 2) or even 4
191            (Tegra 3).
192            </summary>
193    </member>
194    <member name="P:Delta.Engine.SystemInformation.MaxRam">
195      <summary>
196            Maximum ram available on this machine in MB. Might be used by other
197            processes, but still a useful number to know. On Windows machines
198            most of this can usually be used for a big game, on mobile devices it
199            is more important to check how much memory is really left as there is
200            no virtual memory and memory used by other applications is only freed
201            if they are closed down by the OS.
202            </summary>
203    </member>
204    <member name="P:Delta.Engine.SystemInformation.UsedRam">
205      <summary>
206            Gets the amount of used ram in MB by this process. We cannot really
207            control how much memory is going to be freed, but we can make sure
208            to unload content and garbage collect after a game or level is
209            finished.
210            </summary>
211    </member>
212    <member name="P:Delta.Engine.SystemInformation.AvailableRam">
213      <summary>
214            Available ram in MB, which is especially important on mobile devices.
215            If this goes close to 0, we cannot load any more content, especially
216            images. Either other content needs to be unloaded or the device OS
217            needs to be asked to free up some more memory. Worst case scenario is
218            that the OS will close this app because it needs too much memory and
219            is still requesting more, which is obviously not good. On some
220            platforms (e.g. iOS) this is called UserRam because MaxRam is usually
221            way bigger and not usable because much of it is already taken.
222            </summary>
223    </member>
224    <member name="P:Delta.Engine.SystemInformation.Version">
225      <summary>
226            Returns the engine version that is currently used. The current engine
227            version is v0.9.3 (this will be increased each release).
228            </summary>
229    </member>
230    <member name="P:Delta.Engine.SystemInformation.MaxVertexShader">
231      <summary>
232            Returns the max. supported Vertex Shader version that is supported on
233            the current system. The minor shader version is ignored, 1 means
234            vertex shader 1.1 is available, 2 (most common on mobile devices)
235            means vertex shader 2.0 is available, 3, 4 and 5 is for DirectX 9.0c,
236            10 and 11.
237            </summary>
238    </member>
239    <member name="P:Delta.Engine.SystemInformation.MaxPixelShader">
240      <summary>
241            Returns the max. supported Pixel Shader version that is supported
242            on the current system. The minor shader version is ignored, 1 means
243            pixel shader 1.1 is available, 2 (most common on mobile devices)
244            means vertex shader 2.0 is available, 3, 4 and 5 is for DirectX 9.0c,
245            10 and 11. More detailed information can be requested using the
246            concrete graphic framework (e.g. XNA, OpenTK or SharpDX).
247            </summary>
248    </member>
249    <member name="P:Delta.Engine.SystemInformation.IsShaderSupported">
250      <summary>
251            Checks if the current graphics card can use Shaders.
252            </summary>
253      <returns>Returns 'true' if Shaders are supported.</returns>
254    </member>
255    <member name="P:Delta.Engine.SystemInformation.SoundCardAvailable">
256      <summary>
257            Flag determining if a sound card is available for music, sound and
258            video playback or if this feature is not available on the current
259            platform.
260            </summary>
261    </member>
262    <member name="P:Delta.Engine.SystemInformation.MaxSoundChannels">
263      <summary>
264            How many sound channels does this device support? If this is 0 no
265            sound card is installed or can be used. To disable sound in the app
266            use the Settings.Modules.IsSoundEnabled property. Usually this number
267            is 4 or much higher (100), but there is obviously also a performance
268            impact if using too many sounds at the same time.
269            The engine currently allows only the number of this property for
270            simultaneously played sounds.
271            </summary>
272    </member>
273    <member name="T:Delta.Engine.SettingsNodes.ModulesSettings">
274      <summary>
275            Modules settings
276            </summary>
277    </member>
278    <member name="M:Delta.Engine.SettingsNodes.ModulesSettings.#ctor">
279      <summary>
280            Create modules settings is not allowed, only Settings can do this!
281            </summary>
282    </member>
283    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.GraphicModule">
284      <summary>
285            Graphic module, can be multiple entries separated by commas.
286            The name of this module is the assembly name minus Delta.Graphics.
287            This can be whatever assembly can be found in the current directory
288            that contains an Graphic class (will be searched by Factory).
289            <para />
290            On Windows OpenTK works fine and does not need any extra installation.
291            For more advanced DirectX 11 features just use SharpDX!
292            Most mobile and console platforms will use some form of OpenGL,
293            WP7 and Xbox 360 use XNA.
294            </summary>
295    </member>
296    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.EmulatorName">
297      <summary>
298            Emulator name in case we are trying to use some Emulator on Windows.
299            One example is OpenGL ES, which does not exist for windows, but still
300            can be tested with an OpenGL ES emulator like the one from PowerVR.
301            </summary>
302    </member>
303    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.AudioModule">
304      <summary>
305            Audio module, mostly OpenAL, DirectX or XNA as implemented by the
306            native platform or OpenTK, SharpDX or XNA.
307            The name of this module is the assembly name minus Delta.Multimedia.
308            This can be whatever assembly can be found in the current directory
309            that contains an Sound or Music class (will be searched by Factory)
310            </summary>
311    </member>
312    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.VideoModule">
313      <summary>
314            Video module, which is mostly a platform specific implementation that
315            only works on the current platform (e.g. MonoTouch for iOS), but for
316            Windows, Linux and MacOS Vlc is used, which works on all of those.
317            The name of this module is the assembly name minus Delta.Multimedia.
318            This can be whatever assembly can be found in the current directory
319            that contains an Video class (will be searched by Factory)
320            <para />
321            This is empty by default, but if video playback is needed just use Vlc.
322            OpenTK does not help us for video playback, so try to use the Vlc
323            library (open source too) for video playback on Windows.
324            </summary>
325    </member>
326    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.InputModule">
327      <summary>
328            Input module is just "Windows" by default, but can be changed to any
329            other input module to support more features and game controllers.
330            The name of this module is the assembly name minus Delta.InputSystem.
331            This can be whatever assembly can be found in the current directory
332            that contains an Input class (will be searched by Factory)
333            <para /> 
334            For Input in Windows, it is much better to have the more accurate
335            keyboard and mouse event system instead of polling from Xna, if
336            you want to support XnaTouch or XnaGamePad, you need to add this
337            here. Same goes for WiimoteAccelerometer, WiimoteGamePad and even
338            MultiMouse (all advanced features, not enabled by default).
339            A complex example might be "Wiimote, MultiMouse, Xna, Windows" to
340            use all Wiimote, then MultiMouse, then Xna classes and as a fallback
341            the Windows InputSystem (if the others are not available).
342            </summary>
343    </member>
344    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.PhysicsModule">
345      <summary>
346            Physics module(s) that should be used for this application.
347            Default physics module is empty, but Jitter is used by default when
348            you enable physics in the Content Manager Settings, because it works
349            for 3D and 2D, but for 2D Farseer is usually all you need (which can't
350            do 3D however). JigLib is also an option (if Jitter is missing), but
351            vanilla JigLibX requires the XNA 4.0 assemblies for testing!
352            <para />
353            Other options are in the future Apex and PhysX, Ageia, Havoc and
354            others, but keep in mind that many of these will NOT work on all
355            platforms, JigLib and Farseer do.
356            <para />
357            By default this is empty, but you can select any physics engine on
358            Windows and most of them work on all other platforms as well. Use
359            the Content Manager Settings dialog to change.
360            </summary>
361    </member>
362    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.IsSoundEnabled">
363      <summary>
364            Is true if it's allowed to play any sound effects. Note: That
365            doesn't affect playing music. This is sometimes used as a game setting
366            to enable/disable sounds, but usually it is a debug setting.
367            </summary>
368    </member>
369    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.IsMusicEnabled">
370      <summary>
371            Is true if it's allowed to play any music. Note: That doesn't affect
372            playing sound effects. This is sometimes used as a game setting
373            to enable/disable sounds, but usually it is a debug setting.
374            </summary>
375    </member>
376    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.IsVideoEnabled">
377      <summary>
378            If this is false, no videos will be played (every call to Play will
379            just return and the screen will continue to the next one usually).
380            Usually used to skip intro videos to speed up the startup (for testing
381            or if users are annoyed by videos ^^)
382            </summary>
383    </member>
384    <member name="P:Delta.Engine.SettingsNodes.ModulesSettings.IsTouchEnabled">
385      <summary>
386            If this is false, no touch input will be processed. This is useful to
387            optimize on platforms where touch input is not available or where it
388            might be very iffy (e.g. Windows 7 can do multi touch, but almost
389            no one has a multi touch capable screen). By default true.
390            </summary>
391    </member>
392    <member name="T:Delta.Engine.Dynamic.DynamicModule">
393      <summary>
394            Base class for all modules. Derived classes do need to implement the Run
395            method and you need to setup your parent type in the constructor. Each
396            Module has a name and provides a link to the parent module (null is only
397            used for the application module) and all child modules it contains. We
398            also got a method to add child modules via AddModule and SetupParent to
399            setup the parents later when we execute the modules (this delayed
400            creation has the advantage that we can have much more code in the
401            constructors without forcing to create parent modules yet). Most module
402            do not really care where stuff is happening, all data must be known),
403            all we need is the Run method, which will handle all the work!
404            </summary>
405    </member>
406    <member name="F:Delta.Engine.Dynamic.DynamicModule.isValid">
407      <summary>
408            Value cache for the property IsValid.
409            </summary>
410    </member>
411    <member name="M:Delta.Engine.Dynamic.DynamicModule.#ctor(System.String,System.Type)">
412      <summary>
413            Create base module. Only uses a name and parent type to link it up.
414            The type can be an interface if we don't know the specific class or
415            it can be a specific class to link up with that parent module.
416            NOTE: DynamicModules MUST be created via Factory.Create() in order to
417            be added to ModuleList. If you want to allow construction via new,
418            you must call AddToDynamicModuleList() somewhere in your constructor
419            </summary>
420    </member>
421    <member name="M:Delta.Engine.Dynamic.DynamicModule.ToString">
422      <summary>
423            Since the normal ToString method is boring, provide some more useful
424            information for the debugger and anyone else using this method.
425            </summary>
426      <returns>
427            A <see cref="T:System.String" /> that represents this instance.
428            </returns>
429    </member>
430    <member name="M:Delta.Engine.Dynamic.DynamicModule.Run">
431      <summary>
432            Run code, implement whatever you want to have executed. Some modules
433            have no run code, they are just initialized and don't execute anything
434            special. Usually this method has some code however that will be
435            executed each tick. If not, then just declare an empty Run method,
436            which useful to just make sure capabilities are enabled. Execution is
437            triggered via ExecuteRunLoop, which calls all Run methods.
438            </summary>
439      <remarks>
440            Also note that Run calls can be multi-threaded, which are sync-ed up
441            at the parent's Run method. This could greatly improve performance,
442            especially if we have many children Run methods in parallel.
443            Good post about an ideal multi threading solution with messaging:
444            http://www.zeromq.org/blog:multithreading-magic
445            See RunWithChildrenBefore and RunWithChildrenAfter on how this is
446            implemented here, with runs children multi-threaded if
447            Settings.Extra.MultithreadedModules is turned on (by default it is on).
448            </remarks>
449    </member>
450    <member name="M:Delta.Engine.Dynamic.DynamicModule.Dispose">
451      <summary>
452            Dispose
453            </summary>
454    </member>
455    <member name="P:Delta.Engine.Dynamic.DynamicModule.Name">
456      <summary>
457            Name for this module, only set in the constructor! This is usually
458            the name of this class, but do not confuse this with the module type,
459            each module can have a different purpose for Name, content for example
460            might use it for content loading and unique accessing content!
461            </summary>
462    </member>
463    <member name="P:Delta.Engine.Dynamic.DynamicModule.IsValid">
464      <summary>
465            Valid flag. Disable if Valid was set to false (something failed or we
466            don't want to use this anymore). Default is always enabled.
467            </summary>
468    </member>
469    <member name="P:Delta.Engine.Dynamic.DynamicModule.IsDisposed">
470      <summary>
471            Is this class instance already disposed again? Useful to check if we
472            still can dispose dependant objects (like geometry for graphics).
473            </summary>
474    </member>
475    <member name="T:Delta.Engine.Settings">
476      <summary>
477            Settings class. Holds general information about an application or game
478            using the Delta Engine. Settings.xml will be generated if non-existent.
479            <para />
480            Use DeltaLauncher to change settings or modify the XML file directly.
481            Settings include global application settings like PlayerName, Language
482            or Resolution,<para />but also debug settings like which modules are
483            used for rendering, sound, video, etc. and also all the input commands
484            that are currently hooked up (for movement, hot keys, etc.)
485            <para />
486            See http://wiki.deltaengine.net/Private.Settings.ashx
487            </summary>
488    </member>
489    <member name="M:Delta.Engine.Settings.AlignResolution">
490      <summary>
491            Helper method to align resolution to multiple of 8 or 32 depending
492            on the platform.
493            <para />
494            Note: In most cases the target resolution will already be the
495            device default resolution, which is fitting into this rule anyway!
496            For defaults check out the following link (see Stride), ES 1.1 and
497            ES 2.0 have mostly a multiple of 32, ES 3.0 is a multiple of 8.
498            http://processors.wiki.ti.com/index.php/Render_to_Texture_with_OpenGL_ES
499            <para></para>
500            Some examples how fast each resolution is: All are multiples of
501            32 except 600, 720 and some other bigger Tegra and PC
502            resolutions, these are still multiples of 8 pixels however:
503            480*320   = 153600 Pixels (default iPhone and iPod resolution)
504            512*320   = 163840 Pixels (custom low resolution for performance)
505            640*384   = 245760 Pixels (custom low resolution for performance)
506            800*480   = 384000 Pixels (default for WP7, Android Mobiles)
507            960*640   = 614400 Pixels (default iPhone 4 Resolution)
508            1024*600  = 614400 Pixels (older/smaller Tegra Tablet resolution)
509            1024*768  = 786432 Pixels (iPad and older Windows Resolution)
510            1280*720  = 921600 Pixels (Medium HD Resolution)
511            1366*768  = 1049088 Pixels (bigger Tegra Tablet resolution)
512            1680*1050 = 1764000 Pixels (PC resolution 20-22 inch displays)
513            1920*1080 = 2073600 Pixels (Full HD Resolution, lots of pixels)
514            As you can see going Medium or even Full HD is a lot of pixels!
515            Pixel shaders on mobile devices are not very fast, so if you have
516            complex shaders, reduce the resolution to still achieve good
517            performance or only use simple shaders to render as fast as
518            possible!
519            </summary>
520    </member>
521    <member name="M:Delta.Engine.Settings.Equals(System.Object,System.Object)">
522      <summary>
523            Equals, just to hide the visibility of this method.
524            </summary>
525      <param name="objA">First object</param>
526      <param name="objB">Second object</param>
527      <returns>True if both objects are equal</returns>
528    </member>
529    <member name="M:Delta.Engine.Settings.ReferenceEquals(System.Object,System.Object)">
530      <summary>
531            Reference equals
532            </summary>
533      <param name="objA">First object</param>
534      <param name="objB">Second object</param>
535      <returns>
536            True if both objects are the same instance, otherwise false.
537            </returns>
538    </member>
539    <member name="M:Delta.Engine.Settings.Load">
540      <summary>
541            Loads the settings from file. This will first check if the file
542            is locally accessible. If that's true, we load it from there. If not
543            we try to load it from the content path. The content settings file is
544            only loaded once, after that we always use the local setting file!
545            </summary>
546    </member>
547    <member name="M:Delta.Engine.Settings.Save">
548      <summary>
549            Save the settings to local file. Xml data is written by hand until
550            XmlHelper is useful again.
551            </summary>
552    </member>
553    <member name="M:Delta.Engine.Settings.SetDefaultsFromContent(Delta.Utilities.Xml.XmlNode)">
554      <summary>
555            Set the defaults from the content DefaultSettings.xml. If the
556            Settings.xml already existed and was loaded, only the Modules part
557            is replaced, otherwise the whole Settings is replaced and loaded.
558            </summary>
559      <param name="node">
560            The xml node data to load the default settings from. This has most
561            likely already be done in the constructor, but if that failed we set
562            everything again here.
563            </param>
564    </member>
565    <member name="F:Delta.Engine.Settings.DefaultResolution">
566      <summary>
567            Default resolution, will return the default resolution on each
568            platform, which is often the only resolution supported or a good
569            standard value. On Windows it will be 1024x768, which is nice
570            for debugging and testing iPad, iPhone, etc. platforms.
571            Internal because this is used as a fallback for invalid resolutions
572            in ScreenSpace.CalculateAspectRatio.
573            </summary>
574    </member>
575    <member name="F:Delta.Engine.Settings.CommonResolutions">
576      <summary>
577            List of CommonResolutions used by most devices. Used mostly by tools
578            to group common resolutions for most devices together. Also used for
579            fonts, each font needs a configuration for all of these resolutions.
580            For tools and fonts it works like this: We go up this list until
581            we reach a point where our current resolution is bigger than the
582            given one. Then we stop and use that resolution. For example 1600x1200
583            would go up to 1280x720 because 1920x1080 does not fit anymore.
584            </summary>
585    </member>
586    <member name="F:Delta.Engine.Settings.Extra">
587      <summary>
588            Extra settings for more detailed settings, initialized in constructor.
589            </summary>
590    </member>
591    <member name="F:Delta.Engine.Settings.Modules">
592      <summary>
593            Modules settings for all used modules (graphics, sound, physics, etc.)
594            Initialized and loaded in constructor. Please note that the
595            Settings.xml does not contain any Module settings, only the fallback
596            values are set in the ModulesSettings class. Once the DefaultSettings
597            from the content have been loaded, the actual used modules are set.
598            </summary>
599    </member>
600    <member name="F:Delta.Engine.Settings.Debug">
601      <summary>
602            Debug settings, initialized in constructor, can be accessed from
603            everywhere (no matter if in debug mode or not) because the default
604            settings are useful and sometimes even required (like Content path).
605            </summary>
606    </member>
607    <member name="F:Delta.Engine.Settings.Optional">
608      <summary>
609            Optional settings that can be saved to the settings file. Getting data
610            out is a little bit more cumbersome (via strings), but should work
611            fine for any game or application that needs a little extra :)
612            </summary>
613    </member>
614    <member name="P:Delta.Engine.Settings.PlayerName">
615      <summary>
616            The name of the player. Can be changed by the application.
617            </summary>
618    </member>
619    <member name="P:Delta.Engine.Settings.AvailableLanguages">
620      <summary>
621            List of available languages for this application. Localization will
622            contain text entries for each of these languages and content entries
623            like images can be localized in these languages as well. Use Language
624            for the currently selected language! Note: This is read-only!
625            </summary>
626    </member>
627    <member name="P:Delta.Engine.Settings.Language">
628      <summary>
629            Gets or sets the currently selected language of the application.
630            You are only allowed to switch to a supported language listed in the
631            AvailableLanguages list. Can be changed by the application.
632            </summary>
633    </member>
634    <member name="P:Delta.Engine.Settings.Resolution">
635      <summary>
636            Returns the current resolution from the settings. This WILL NOT change
637            the current running window or viewport, use Application.Window to do
638            that (they call this property too and will make sure it is all sync-ed
639            up). This are the setting for the next time we load settings. For this
640            reason setting the Settings resolution is internal and should not be
641            done via game code. Instead change your content project settings or use
642            Application.Window.Resize to do dynamic resizing in your application.
643            <para></para>
644            For best performance, we ensure the render-buffer height and width
645            are each a multiple of 8 pixels (32 pixels for iOS and WP7, but
646            this limit is not consistent on Android, e.g. the PC or Tegra can
647            render 720p or 1024x600 (both not a multiple of 32) totally fine).
648            See AlignResolution, which will be called when loading or saving!
649            </summary>
650    </member>
651    <member name="E:Delta.Engine.Settings.LanguageChanged">
652      <summary>
653            This event occurs every time the language settings will be changed.
654            </summary>
655    </member>
656    <member name="M:Delta.Engine.Settings.SettingsTests.OptionalSettings">
657      <summary>
658            Optional settings
659            </summary>
660    </member>
661    <member name="T:Delta.Engine.Dynamic.RequireAttribute">
662      <summary>
663            For types which require a given type to have its implementation
664            determined first. This attribute enforces given type to be instantiated
665            first. Usually given type should be a singleton type.
666            </summary>
667    </member>
668    <member name="M:Delta.Engine.Dynamic.RequireAttribute.#ctor(System.Type,Delta.Engine.SettingsNodes.ModuleType)">
669      <summary>
670            Create require attribute.
671            </summary>
672      <param name="setRequiredType">The type that is required.</param>
673      <param name="setSetting">The settings item that should be
674            checked for creating an implementation of this type.</param>
675    </member>
676    <member name="P:Delta.Engine.Dynamic.RequireAttribute.RequiredType">
677      <summary>
678            Required type.
679            </summary>
680      <value>
681            The type of the required.
682            </value>
683    </member>
684    <member name="P:Delta.Engine.Dynamic.RequireAttribute.Setting">
685      <summary>
686            Settings item.
687            </summary>
688    </member>
689    <member name="T:Delta.Engine.Application">
690      <summary>
691            The Application.Start method starts the whole game and engine up. You
692            can provide derived a Application class if you need different
693            implementations on other platforms and override the methods (e.g.
694            IPhoneApplication calls its own Main method, it can't use a while loop).
695            Each platform has its own implementation of this class, which is 99%
696            the same, just the startup sequence and RunTick is a little different.
697            </summary>
698    </member>
699    <member name="F:Delta.Engine.Application.information">
700      <summary>
701            System information instance, only initialized when the Information
702            property is used (which it not happening often).
703            </summary>
704    </member>
705    <member name="F:Delta.Engine.Application.BackgroundColor">
706      <summary>
707            Represents the color which that the back buffer will be cleared. Can
708            be changed from everywhere. By default is Black which means we will
709            clear the back buffer with the black color each frame, in unit tests
710            this is changed to DarkBlue by default. You can also set the background
711            color to Uused, which speeds up rendering because it results in not
712            clearing of the (native) backbuffer. This is useful when we already
713            have a "fullscreen background" (2D or 3D scene) rendered.
714            </summary>
715    </member>
716    <member name="M:Delta.Engine.Application.Start">
717      <summary>
718            Start application. You should do some initialization code before
719            calling this as this will immediately quit if you have 0 modules
720            (because there is no optionalRunCode or module in this overload).
721            </summary>
722    </member>
723    <member name="M:Delta.Engine.Application.Start(Delta.Engine.Dynamic.DynamicModule)">
724      <summary>
725            Start application with given main dynamic module (the game or
726            application or first module we want to run), which is inserted to the
727            Application.Run if it was not done before. Then this method will start
728            the execution loop, which will call Run for all modules and block until
729            quitting via the Quit() method.
730            </summary>
731      <param name="initialModule">The main dynamic module to run
732            the application with.</param>
733    </member>
734    <member name="M:Delta.Engine.Application.Start(Delta.Engine.Dynamic.RunDelegate)">
735      <summary>
736            Start the application and start the execution loop, which will call
737            Run for all modules and block until quitting via the Quit() method.
738            </summary>
739      <param name="setOptionalRunCode">Set optional run code.</param>
740    </member>
741    <member name="M:Delta.Engine.Application.Quit">
742      <summary>
743            Quit the currently running application, will close the game loop
744            and dispose all content and classes (via Base.Dispose()).
745            </summary>
746    </member>
747    <member name="F:Delta.Engine.Application.ApplicationStarted">
748      <summary>
749            Delegate event fired when the Application.Instance is created and
750            used for post startup code like the Settings Defaults.
751            </summary>
752    </member>
753    <member name="F:Delta.Engine.Application.ApplicationClosing">
754      <summary>
755            Delegate event fired when the Application is closing and
756            used for disposing native instances like the VLC manager when closing
757            the application.
758            </summary>
759    </member>
760    <member name="F:Delta.Engine.Application.quit">
761      <summary>
762            Set this variable to true to quit the application loop. Usually done
763            in the Quit method, which can do different things on each platform,
764            but should always set this variable to true to quit the game loop.
765            We also keep an extra variable hasStartedYet to check if we have
766            called the Start method already. All content loading should be delayed
767            and if content is loaded before Start a warning will be shown by
768            Content.Data, which should be fixed with delayed content loading.
769            </summary>
770    </member>
771    <member name="F:Delta.Engine.Application.hasStartedYet">
772      <summary>
773            See quit
774            </summary>
775    </member>
776    <member name="F:Delta.Engine.Application.optionalRunCode">
777      <summary>
778            Optional run code, that will be set in Start and called in Run.
779            </summary>
780    </member>
781    <member name="M:Delta.Engine.Application.#ctor">
782      <summary>
783            Create base application. The application just provides the run
784            loop, which will be started in the Start method (platform specific).
785            </summary>
786    </member>
787    <member name="M:Delta.Engine.Application.StartExecutionLoop">
788      <summary>
789            Start execution loop, used internally, overwrite this one if you need
790            a different way, e.g. on some platforms like iPhone we have to provide
791            a different way to start the application without our own while loop,
792            but using event based methods to then call the Run method.
793            Note: In release mode this also will catch exception in the while
794            loop. This way we can continue in the game loop without crashing
795            the whole app. In debug mode this makes not so much sense, use the
796            attached debugger instead to figure out what is wrong.
797            </summary>
798    </member>
799    <member name="M:Delta.Engine.Application.Run">
800      <summary>
801            The run method is our main execution loop we call every single frame.
802            First the graphic rendering is executed to give work to the GPU, which
803            should work parallel to the CPU as much as possible each frame. Then
804            we execute Time, Input and Physics because all game logic depends on
805            these modules and will use their data. If we have optionalRunCode
806            (usually used for unit tests) that is executed next and finally all
807            the other modules are executed (scenes, game logic, etc.). Most
808            calculation should happen here and all GPU rendering is collected for
809            the next frame where we will render it all out at the beginning of the
810            frame! The cool thing about DynamicModules is that they are all
811            executed automatically for us, we only handle Graphic and Time
812            specially because we want them to be executed in this very special
813            way, but they are still DynamicModules and work exactly the same as
814            the rest of all modules.
815            </summary>
816    </member>
817    <member name="M:Delta.Engine.Application.Dispose">
818      <summary>
819            After the run loop returns, the we are done executing. Dispose main
820            application modules and do some cleanup here. Dispose is based on the
821            DynamicModule.Dispose, which does kill all the children modules for
822            us automatically in the reverse order they were created and linked up.
823            </summary>
824    </member>
825    <member name="M:Delta.Engine.Application.Error(System.String)">
826      <summary>
827            Error, will try to output the error in the console, log and as display
828            a dialog if possible on this platform and in the current game state.
829            See HandleUnhandledException (the usual caller) for more details.
830            Note: Only used internally for heavy errors, normal application
831            warnings should just be logged and fatal errors should throw an
832            exception (which will be caught by HandleUnhandledException if
833            nothing else catches it).
834            </summary>
835      <param name="message">Detailed error message</param>
836      <returns>True if the error should be ignored in the future,
837            false if not (application might already be aborting or the caller
838            can decide to abort in this case).</returns>
839    </member>
840    <member name="M:Delta.Engine.Application.Error(System.String,System.Object)">
841      <summary>
842            Error, will try to output the error in the console, log and as display
843            a dialog if possible on this platform and in the current game state.
844            See HandleUnhandledException (the usual caller) for more details.
845            Note: Only used internally for heavy errors, normal application
846            warnings should just be logged and fatal errors should throw an
847            exception (which will be caught by HandleUnhandledException if
848            nothing else catches it).
849            </summary>
850      <param name="message">Detailed error message</param>
851      <param name="exceptionObject">The exception object for more details.
852            </param>
853      <returns>True if the error should be ignored in the future,
854            false if not (application might already be aborting or the caller
855            can decide to abort in this case).</returns>
856    </member>
857    <member name="M:Delta.Engine.Application.ShowNoContentErrorDialog(System.String,System.String,System.Boolean,Delta.Engine.Dynamic.LoginDelegate,Delta.Engine.Dynamic.GetContentProjectsDelegate,Delta.Engine.Dynamic.GetAutocompleteProjectNamesDelegate,Delta.Engine.Dynamic.SelectContentProjectDelegate)">
858      <summary>
859            Show no content error dialog, which is mostly the same as
860            ShowErrorDialog on most platforms. On Windows in debug mode however
861            we allow grabbing content dynamically via a connect to the Content
862            Server. This is asked in this several dialogs, which makes this method
863            quite complicated. All data is returned via the delegates to the
864            caller. If the data is invalid or the connect could not been made, the
865            callbacks will return errors and this method will try again and again.
866            Note: This will block the app and should only be called for serious
867            content errors that prevent us from continuing (no content available).
868            </summary>
869      <param name="message">
870            Message to display. Initially this will be a warning about not having
871            content, but might also be a connection error or wrong login data.
872            </param>
873      <param name="username">Username to login, can be remembered</param>
874      <param name="clientAlreadyConnected">Is the client already connected?
875            Then we only need to select the content project, nothing more.</param>
876      <param name="loginCallback">Callback that is being called when the
877            user has entered his login information.</param>
878      <param name="getListOfContentProjects">Get list of content projects
879            for the ProjectsWindow dialog.</param>
880      <param name="getAutocompleteProjectsCallback">Get follow-able projects
881            when the user enters something in the project text box.</param>
882      <param name="selectContentProjectCallback">And finally selecting one
883            of the projects, will be checked if the user has access.</param>
884      <returns>
885            True if the user entered some data and the caller should try to grab
886            the new content from the connected server, false if we have to quit.
887            </returns>
888    </member>
889    <member name="M:Delta.Engine.Application.ShowLoginDialog(System.String,System.String,System.Boolean,Delta.Engine.Dynamic.LoginDelegate,Delta.Engine.Dynamic.GetContentProjectsDelegate,Delta.Engine.Dynamic.GetAutocompleteProjectNamesDelegate,Delta.Engine.Dynamic.SelectContentProjectDelegate)">
890      <summary>
891            Show no content error dialog, which is mostly the same as
892            ShowErrorDialog on most platforms. On Windows in debug mode however
893            we allow grabbing content dynamically via a connect to the Content
894            Server. This is asked in this several dialogs, which makes this method
895            quite complicated. All data is returned via the delegates to the
896            caller. If the data is invalid or the connect could not been made, the
897            callbacks will return errors and this method will try again and again.
898            Note: This will block the app and should only be called for serious
899            content errors that prevent us from continuing (no content available).
900            </summary>
901      <param name="message">
902            Message to display. Initially this will be a warning about not having
903            content, but might also be a connection error or wrong login data.
904            </param>
905      <param name="username">Username to login, can be remembered</param>
906      <param name="clientAlreadyConnected">Is the client already connected?
907            Then we only need to select the content project, nothing more.</param>
908      <param name="loginCallback">Callback that is being called when the
909            user has entered his login information.</param>
910      <param name="getListOfContentProjects">Get list of content projects
911            for the ProjectsWindow dialog.</param>
912      <param name="getAutocompleteProjectsCallback">Get follow-able projects
913            when the user enters something in the project…

Large files files are truncated, but you can click here to view the full file