<?xml version="1.0"?>

<doc>

    <assembly>

        <name>Delta.ContentSystem.Rendering</name>

    </assembly>

    <members>

        <member name="T:Delta.ContentSystem.Rendering.EffectData">

            <summary>

            The effect data class is the content implementation of a effect and

            handles all the saving and loading of an effect.

            Basically this class only contains a list of Emitters that is filled

            during loading. The further load logic is then in the EmitterData class.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.EffectData.Get(System.String)">

            <summary>

            This is the only method to load XmlData content. If a content object

            has already been loaded, it will be returned again.

            </summary>

            <param name="contentName">Name of the Xml content to load</param>

            <returns>The loaded XmlData object (or fallback if it failed)</returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.EffectData.#ctor(System.String)">

            <summary>

            Create and load new effect data. Use the static Get method to call this.

            </summary>

            <param name="setEffectName">Name of the effect.</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.EffectData.#ctor(System.Collections.Generic.List{Delta.ContentSystem.Rendering.Helpers.EmitterData})">

            <summary>

            Create effect data from list of emitter data. Only used internally

            for the editors, it makes no sense to create content objects in the

            engine itself. You can dynamically create rendering classes like in

            this case a Effect class with custom emitters, but it is not a loaded

            EffectData content class then (the link to data will stay null in the

            Effect class).

            </summary>

            <param name="setEmitters">Set emitter data list</param>

            <exception cref="T:System.NullReferenceException">To create 'EffectData' you 

            have to provide a valid emitter data list!</exception>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.EffectData.Load(System.IO.BinaryReader)">

            <summary>

            Load saved data back into this EffectData, usually only called from

            the Load method above from the Content System.

            </summary>

            <param name="reader">Reader to read the data from</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.EffectData.Save(System.IO.BinaryWriter)">

            <summary>

            Save effect data into stream. Usually called by the tool that saves

            this data out (EffectEditor) or the ContentSystem for optimizations.

            </summary>

            <param name="writer">Writer for the stream to write into</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.EffectData.Load(Delta.ContentSystem.Content)">

            <summary>

            Native load method, will just load or clone the effect data.

            </summary>

            <param name="alreadyLoadedNativeData">

            The first instance that has already loaded the required content data

            of this content class or just 'null' if there is none loaded yet (or

            anymore).

            </param>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.EffectData.Emitters">

            <summary>

            List of emitters.

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.Helpers.GlyphDrawInfo">

            <summary>

            Glyph draw info helper struct, which is used by FontData, but only

            really needed in Delta.Rendering.Basics.Fonts.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.GlyphDrawInfo.DrawArea">

            <summary>

            That represents the area where the glyph (or in other words the

            character) will be drawn on the screen.

            <para/>

            Note: The area will be created in pixel space from the 'FontData' on

            the content side and will give it to the 'Font' class on the rendering

            side. There will the value be transformed in the quadratic space (which

            is the used space in the DeltaEngine for rendering) and reused for

            drawing calls of the 'Font' class.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.GlyphDrawInfo.FontMapId">

            <summary>

            The ID of the font map that belongs to the font where that draw info is

            thought for.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.GlyphDrawInfo.UV">

            <summary>

            The final (normalized) UV coordinates for the font map related to the

            set 'FontMapId'.

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.MaterialData">

            <summary>

            Material data for loading and saving materials through the content

            system as part of a Model or some UI scene. The actual material is

            located in the Delta.Rendering module, which uses this class. This

            class is currently used to just load the MaterialData directly via

            BinaryReader (for embedded materials in models, UI scenes, etc.).

            There are no properties or any dynamic loading in this class.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.VersionNumber">

            <summary>

            Version number for this MaterialData. If this goes above 1, we need

            to support loading older versions as well. Saving is always going

            to be the latest version (this one).

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.Default">

            <summary>

            Default material data, do not modify, just used as fallback data.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.MaterialData.Get(System.String)">

            <summary>

            Get and load content based on the content name. This method makes sure

            we do not load the same content twice (the constructor is protected).

            </summary>

            <param name="contentName">Content name we want to load, this is

            passed onto the Content System, which will do the actual loading with

            help of the Load method in this class.</param>

            <returns>The loaded Content object, always unique for the same

            name, this helps comparing data.</returns>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.ShaderName">

            <summary>

            Link to the shader we want to use with this material as the content

            name. If the content cannot be found or does not exist we will output

            a warning and use a fallback generated shader with the help of

            material data that is already set (e.g. diffuse map and normal map

            is set, then generate a fallback shader that can handle that).

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.DiffuseMapName">

            <summary>

            Diffuse map name, almost always used (else meshes look dull). For

            sky cube map shaders this is used as the sky cube map texture, which

            even can be in HDR mode if the platform supports it. If unused this

            string is empty (same goes for all other strings here), but for

            shaders that need a diffuse map (most do), this will result in using

            the default fallback image for DiffuseMap (see Image.Default)!

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.NormalMapName">

            <summary>

            Normal map name, used for NormalMapping, only used if a normal map

            shader is used. Please note this image might have the red and alpha

            channel swapped if this is supported and wanted through shaders. This

            trick is used to increase quality of compressed normal maps, e.g. DXT1

            compresses nicely (1:6 ratio), but can look crappy for detailed normal

            maps, so DXT5 is used instead (1:4 ratio still) with R and A swapped.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.SpecularMapName">

            <summary>

            Specular map name. Gloss (specular map) mapping effect for a 

            directional or point light shaders.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.HeightMapName">

            <summary>

            Height map name, this is usually used for parallax effects and

            usually a reduced texture because we don't need much precision or

            accuracy for parallax effects. See ShaderConstants for ParallaxHeight.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.DetailMapName">

            <summary>

            Detail map name, this is almost a diffuse map with more details.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.ReflectionCubeMapName">

            <summary>

            Reflection cube map name to make reflections more shiny (uses usually

            the same sky cube map as for the sky cube rendering via DiffuseMap)

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.LightMapName">

            <summary>

            Light map name for mesh data with light mapped images baked on top.

            Only used if a light map shader is used.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.ShaderLutTexture">

            <summary>

            Shader helper texture for pre-calculations. Usually used for 1D or 2D

            texture lookups for specular power and fresnel power with some extra

            pre-calculated data maybe (combined fresnel and specular, already

            applied colors, fresnel factors, etc.).

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.ShadowMapTexture">

            <summary>

            Texture used for performing shadow casting from given object.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.Ambient">

            <summary>

            TODO: Has currently no effect, no shader attribute exists for this yet! All pre-calculated!

            Ambient is usually always 0.15 (the default), many shaders even ignore

            this if all we want is light from light sources.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.Diffuse">

            <summary>

            TODO: Has currently no effect, no shader attribute exists for this yet! All pre-calculated!

            The diffuse color is usually always white (90% by default), but can

            be changed from time to time to other colors. Different diffuse colors

            need a extra shader pass and cannot be merged, it is much quicker to

            let this stay white (the default) and use colored vertices for effects

            or UI, which mostly use the same atlas image, but need all kind of

            different colors per vertex!

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.SpecularPower">

            <summary>

            TODO: Has currently no effect, no shader attribute exists for this yet! All pre-calculated!

            Specular shininess power, usually defaults to DefaultShininess.

            Sometimes not possible on low end pixel shaders, will be optimized

            out or put in the vertex shader instead.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.MaterialData.FresnelPower">

            <summary>

            TODO: Has currently no effect, no shader attribute exists for this yet! All pre-calculated!

            Fresnel power if the shader for this material does fresnel,

            fresnel bias is 0 (or bias in the shader) and the factor is 1.0 too.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.MaterialData.#ctor(System.String)">

            <summary>

            Create a material from content, just makes sure we use the material

            content type, all loading happens in the Load method below.

            Use the static Get method to call this.

            </summary>

            <param name="setMaterialName">

            Name for this content object, should not contain any path, project,

            scene or any special character! If this is empty or starts with an

            &gt; character, we assume this is code generated content

            (e.g. "&gt;IntroScene&lt;" or "") and no loading will happen!

            </param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.MaterialData.#ctor">

            <summary>

            Create a default material data container. All textures are empty,

            just the default color values are used. This has also no content name.

            Use the .NET 3 style constructor to assign values easily.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.MaterialData.Load(System.IO.BinaryReader)">

            <summary>

            Load material data from binary data stream.

            </summary>

            <param name="reader">BinaryReader for reading the data</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.MaterialData.Save(System.IO.BinaryWriter)">

            <summary>

            Save material data, which consists of a bunch of strings and some

            colors plus some additional settings.

            </summary>

            <param name="writer">BinaryWriter for the stream to write into</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.MaterialData.ToString">

            <summary>

            To string

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.MaterialData.Load(Delta.ContentSystem.Content)">

            <summary>

            Native load method, will just load the xml data.

            </summary>

            <param name="alreadyLoadedNativeData">

            The first instance that has already loaded the required content data

            of this content class or just 'null' if there is none loaded yet (or

            anymore).

            </param>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.ImageData">

            <summary>

            Helper class for accessing image content, which is needed in the Texture

            class (but it can also be used in other places when loading images).

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageData.Get(System.String)">

            <summary>

            Get and load content based on the content name. This method makes sure

            we do not load the same content twice (the constructor is protected).

            </summary>

            <param name="contentName">Content name we want to load, this is

            passed onto the Content System, which will do the actual loading with

            help of the Load method in this class.</param>

            <returns>The loaded Content object, always unique for the same

            name, this helps comparing data.</returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageData.GetAllContentNames">

            <summary>

            Get list of all image content names available in the current project.

            </summary>

            <returns>List of all image content names</returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageData.#ctor(System.String)">

            <summary>

            Create a base texture, just makes sure we use the image content type.

            Use the static Get method to call this.

            </summary>

            <param name="setImageName">Set image name</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageData.ToString">

            <summary>

            To string, will display the image name and some extra data.

            </summary>

            <returns>

            A <see cref="T:System.String"/> that represents this ImageData instance

            with the content name, pixel size, blend mode and uv meta data.

            </returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageData.Load(Delta.ContentSystem.Content)">

            <summary>

            Load texture content data. This method does not load the content yet,

            it only provides the common functionality for all derived classes that

            actually contain the image data. No loading happens here (it all

            happens in Texture), we can obviously clone all ImageDatas with the

            same name as they are not loaded here.

            </summary>

            <param name="alreadyLoadedNativeData">If we already have native data

            loaded, clone it from this instance. Only used if not null. Please

            note that this is only used for other objects that had the same

            RawFileId and are already loaded and returned true for this method.

            </param>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.PixelSize">

            <summary>

            The size of the image in pixels (NOT in quadratic space and also NOT

            necessarily the size of the real bitmap from disk, which might be

            an atlas texture that is much bigger than this image size).

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.BlendMode">

            <summary>

            Blend mode used for this image, set in constructor and can't be

            changed. This is important for the MaterialManager sorting logic!

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.UseLinearFiltering">

            <summary>

            Helper property to determinate if we need to enable filtering for

            rendering this image (usually in a shader). True is the default and

            means we are going to use Trilinear filtering, false means no

            filtering, which is often called Nearest or Point filtering.

            Note: For fonts and the default image (4x4 pixels) this is

            automatically set to false for more accurate and sharp rendering.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.AllowTiling">

            <summary>

            Allow tiling for this texture? By default this is off and using this

            prevents us from using atlas textures and many optimizations, so it

            should be avoided as much as possible.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.UV">

            <summary>

            The texture coordinates of this image. Normally (0, 0, 1, 1)

            But necessary when using atlas textures (what we are mostly doing).

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.InnerDrawArea">

            <summary>

            Helper for the inner rectangle for rendering, which will reduce any

            draw rectangle by this to make it fit in case there were empty pixels

            around this image.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.AtlasFileId">

            <summary>

            Atlas file id, needed to compare for atlas textures. Each content file

            with the same PlatformFileId will use the same native texture object

            (sharing it with all the other content entries using the same atlas).

            By comparing this we can quickly group all rendering by atlas textures

            to make best use of draw call batching and speeding up the rendering.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageData.IsCubeMap">

            <summary>

            Is this image data for a cube map texture? Usually off.

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.Helpers.EmitterData">

            <summary>

            Emitter data class, used for EffectData, which just contains a list of

            emitters. Please note that this class can be derived for additional

            functionality and each of the modifiers stored here can also be

            any class using the IEffectModifier interface.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.EmitterData.#ctor">

            <summary>

            Create a new emitter data instance.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.EmitterData.Load(System.IO.BinaryReader)">

            <summary>

            Load the emitter data and all the modifiers.

            </summary>

            <param name="reader">BinaryReader for reading the data</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.EmitterData.Save(System.IO.BinaryWriter)">

            <summary>

            Save the emitter data and all the modifiers.

            </summary>

            <param name="writer">BinaryWriter for the stream to write into</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.EmitterData.ToString">

            <summary>

            To string helper method to print out the name of this emitter instance.

            </summary>

            <returns>String representing this EmitterData instance (name)</returns>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.Helpers.EmitterData.Name">

            <summary>

            The name of the Emitter.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.Helpers.EmitterData.Modifiers">

            <summary>

            The list of modifiers for this emitter.

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.ImageAnimationData">

            <summary>

            Helper class for accessing image animations, which is just a collection

            of images, but with all important meta data for them. All images are

            just children and can be accessed easily with this class.

            <para />

            Please note that Image Animations just contain images and have no data

            own their own (just meta data).

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageAnimationData.Get(System.String)">

            <summary>

            Get and load content based on the content name. This method makes sure

            we do not load the same content twice (the constructor is protected).

            </summary>

            <param name="contentName">Content name we want to load, this is

            passed onto the Content System, which will do the actual loading with

            help of the Load method in this class.</param>

            <returns>The loaded Content object, always unique for the same

            name, this helps comparing data.</returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageAnimationData.#ctor(System.String)">

            <summary>

            Create image animation instance, which just holds some meta data and

            the list of images for this animation (see Images property).

            Use the static Get method to call this.

            </summary>

            <param name="setImageAnimationName">

            Name for this content object, should not contain any path, project,

            scene or any special character! If this is empty or starts with an

            &gt; character, we assume this is code generated content

            (e.g. "&gt;IntroScene&lt;" or "") and no loading will happen!

            </param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageAnimationData.ToString">

            <summary>

            To string, will display the image animation images list.

            </summary>

            <returns>

            A <see cref="T:System.String"/> that represents this ImageAnimationData

            instance with the list of image names.

            </returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ImageAnimationData.Load(Delta.ContentSystem.Content)">

            <summary>

            Load animated image content data, will just set the Images property.

            </summary>

            <param name="alreadyLoadedNativeData">

            Ignored here, can't be cloned.

            </param>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageAnimationData.Images">

            <summary>

            List of images that are children to this ImageAnimation content node.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageAnimationData.AnimationSpeed">

            <summary>

            Animation speed in FPS. 30 means we got 30 animations per second, 12

            means we only have 12 animations that are played per second (default).

            Used for 2D animated image sequences, but also for 3D Models using

            animations. The default value is 30 and usually used for all animated

            content unless it is optimized for 15 fps or less to save memory.

            Note: Not used if each of the images has its own AnimationLengthInMs!

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageAnimationData.AnimationIndicesAndMs">

            <summary>

            Animation frame indices and their lengths in milliseconds for whatever

            crazy animation logic you want to build. Usually unused (0), but if

            this is used for all animated images in a sequence, you can control

            how quickly each part of the animation is played back. You are not

            forced to play the animation in order and you can repeat frames as

            many times as you like and make the animation as long as you want (see

            TotalAnimationLengthMs). AnimationSpeed (see above) is also ignored,

            you need to set each of these frame length times yourself.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageAnimationData.PixelSize">

            <summary>

            Size of the images in this animation in pixels. Each animation image

            can have its own PixelSize, but this is the important size used for

            displaying this image animation (children can be bigger or smaller).

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageAnimationData.BlendMode">

            <summary>

            Blend mode used for all images, set in data and can't be changed.

            This is important for the MaterialManager sorting logic!

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ImageAnimationData.UseLinearFiltering">

            <summary>

            Helper property to determinate if we need to enable filtering for

            rendering this images (usually in a shader). True is the default and

            means we are going to use Trilinear filtering, false means no

            filtering, which is often called Nearest or Point filtering.

            Note: For fonts and the default image (4x4 pixels) this is

            automatically set to false for more accurate and sharp rendering.

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.Helpers.IEffectModifier">

            <summary>

            Interface for the effect modifiers, which all implement ISaveLoadBinary.

            We currently use the interface because the Modifier itself shouldn't

            be in the here (in Delta.ContentSystem) and especially not the Particle

            struct which is needed in the Base Modifier class.

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.FontData">

            <summary>

            That class takes care about the correct loading of the requested bitmap

            font based on the given parameters in the constructor. The font bitmap

            textures itself (font maps) will be created by the FontGenerator of the

            ContentServer.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.MinFontSize">

            <summary>

            The minimal size (in points) that a font is allowed to have.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.MaxFontSize">

            <summary>

            The maximal size (in points) that a font is allowed to have.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.NoChar">

            <summary>

            Helper constant to initialize the "char" variables

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.FallbackChar">

            <summary>

            The fallback character which is used if a character isn't supported by

            a font.

            </summary>

            <remarks>

            Is used for parsing a text.

            </remarks>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.Get(System.String)">

            <summary>

            Get and load content based on the content name. This method makes sure

            we do not load the same content twice (the constructor is protected).

            </summary>

            <param name="contentName">Content name we want to load, this is

            passed onto the Content System, which will do the actual loading with

            help of the Load method in this class.</param>

            <returns>The loaded Content object, always unique for the same

            name, this helps comparing data.</returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.Get(System.String,System.Int32,Delta.Utilities.Graphics.FontStyle)">

            <summary>

            Get or load a font without the content name, but instead by searching

            for all the meta data: Font Family Name, Font Size and Font Style.

            Please note that other values like Font Tracking is ignored, you have

            to use the Get(contentName) overload for that.

            <para />

            This method will always return a font. If just a style or size was not

            found a content entry with the same font family is returned. If that

            is also not found the default font is returned (which is part of each

            project because the Engine content is always available as fallback

            content).

            </summary>

            <param name="fontFamilyName">Font family name (like "Verdana",

            "Arial", etc.).</param>

            <param name="fontSize">Font size (like 9pt, 12pt, 24pt, etc.).</param>

            <param name="fontStyle">Font style flags (bold, italic, sharp, etc.)

            </param>

            <returns>The loaded FontData content object. If this content was loaded

            before the same copy is used again.</returns>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.ResolutionFonts">

            <summary>

            Font content entries can either be concrete font settings with an

            xml file for all the glyph data or just a parent entry with children

            that contain the resolution specific font data (4 children for the 4

            default resolutions, see Font.DetermineBestFont, which switches fonts

            at 480x320, 800x480, 1024x768 and 1920x1080).

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.glyphDictionary">

            <summary>

            Dictionary of each unicode character we have in the font maps and can

            use for drawing.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.defaultData">

            <summary>

            Default data

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.FontData.kernDictionary">

            <summary>

            Character spacing with kerning dictionary, which tells us how much

            spacing is needed between two characters. Most character combinations

            have no extra values in here, but some have (like W, I, etc.)

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.#ctor(System.String)">

            <summary>

            Creates a font from the content data. All font data is stored in xml

            files (in the Fonts content directory). Will also load all bitmaps

            required for this font.

            </summary>

            <param name="contentName">Font content name to load. If this is empty

            no content will be loaded (just fallback data will be set).</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.GetGlyphDrawInfos(System.String,System.Single,Delta.Utilities.Datatypes.Advanced.HorizontalAlignment)">

            <summary>

            Return the draw info of all glyphs that are needed to show the text

            on the screen (in pixel space).

            <para/>

            ASCII reference:

            http://www.tcp-ip-info.de/tcp_ip_und_internet/ascii.htm

            <para/>

            Note: The glyph info exists as single array but the data itself

            represents the text inclusive line breaks, so in other words the

            several text lines are "flattened" to a single-dimensioned array.

            </summary>

            <param name="text">Text</param>

            <param name="lineSpacing">Line spacing</param>

            <param name="textAlignment">Horizontal text alignment mode</param>

            <returns>

            List of GlyphDrawInfos ready for drawing.

            </returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.GetGlyphDrawInfos(System.String,System.Single,Delta.Utilities.Datatypes.Advanced.HorizontalAlignment,System.Boolean,System.Boolean,Delta.Utilities.Datatypes.Size@)">

            <summary>

            Return the draw info of all glyphs that are needed to show the text

            on the screen (in pixel space).

            <para/>

            ASCII reference:

            http://www.tcp-ip-info.de/tcp_ip_und_internet/ascii.htm

            <para/>

            Note: The glyph info exists as single array but the data itself

            represents the text inclusive line breaks, so in other words the

            several text lines are "flattened" to a single-dimensioned array.

            </summary>

            <param name="text">Text</param>

            <param name="lineSpacing">Line spacing</param>

            <param name="textAlignment">Horizontal text alignment mode</param>

            <param name="isClippingOn">Is clipping check required</param>

            <param name="maxTextSize">Max. available size in Pixel Space</param>

            <param name="isWordWrapOn">

            Indicates if the words of the given text should be wrapped or clipped

            (if enabled) at the end of a text line.

            </param>

            <returns>

            List of GlyphDrawInfos ready for drawing.

            </returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.ToString">

            <summary>

            To String method, will just extend the Content.ToString method by

            some extra font meta information.

            </summary>

            <returns>A info string about this object instance.</returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.Load(Delta.ContentSystem.Content)">

            <summary>

            Native load method, will just load the xml data.

            </summary>

            <param name="alreadyLoadedNativeData">

            The first instance that has already loaded the required content data

            of this content class or just 'null' if there is none loaded yet (or

            anymore).

            </param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.ParseText(System.String)">

            <summary>

            Parses the given text by analyzing every character to decide if the

            current is supported or not. Every character that is not drawable will

            be replaced by the "fallback character" (or skipped if the font doesn't

            support even that). Addtionally by checking the characters also (every

            tyoe of) line breaks will be detected and teh text splitted by them.

            </summary>

            <param name="text">Text</param>

            <remarks>

            This method has no validation checks because every caller makes already

            sure that the text is valid.

            </remarks>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.GetTextLines(System.String,System.Single,Delta.Utilities.Datatypes.Size,Delta.Utilities.Datatypes.Advanced.HorizontalAlignment,System.Boolean,System.Boolean,System.Collections.Generic.List{System.Single}@,System.Single@)">

            <summary>

            Gets the single text lines of multi line text by determining the line

            breaks. Each of the detected text line will be represented as a list of

            chars whereby only "known" characters will be listed here or at least

            represented by a question mark. All other characters will skipped and

            logged out.

            </summary>

            <remarks>

            This method will also handle clipping and word-wrapping.

            </remarks>

            <param name="text">Text</param>

            <param name="lineSpacing">Line spacing</param>

            <param name="maxTextSize">Maximum text size</param>

            <param name="textAlignment">Text alignment</param>

            <param name="isClippingOn">Is clipping on</param>

            <param name="isWordWrapOn">Is word wrap on</param>

            <param name="textlineWidths">Textline widths</param>

            <param name="maxTextlineWidth">Maximum textline width</param>

            <returns>

            The list of final text lines where the words contains only allowed

            characters.

            </returns>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.FontData.Default">

            <summary>

            The font data which is chosen by default if a concrete one is not

            available (yet). This is always Verdana, 12pt, with an outline.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.FontData.FamilyName">

            <summary>

            The family name of the font, e.g. Verdana, Consolas, etc.

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.FontData.SizeInPoints">

            <summary>

            The size of the font in points, e.g. 12, 14, etc.

            </summary>

            <returns>Int</returns>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.FontData.Style">

            <summary>

            The style how the characters will be shown, e.g. normal, bold, italic,

            etc.

            </summary>

            <returns>Font style</returns>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.FontData.Tracking">

            <summary>

            Defines the distance (in normalized percentage) which is added between

            2 characters. This is only used for this FontData and set by the

            content system (cannot be changed by the user, unlike

            Font.TrackingMultiplier, which is just a multiplier to adjust spacing).

            <para/>

            0.0 means no additional space (default)

            <para/>

            1.0 means 100% of the AdvanceWidth of the character as additional space

            to the right.

            <para/>

            -1.0 means 100% of the AdvanceWidth of the character as "reverse" space

            to the left.

            </summary>

            <returns>Int</returns>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.FontData.LineHeight">

            <summary>

            The height of the font in pixel space based on the set font size.

            <para/>

            CAUTION: That is not the final height of the font on the screen!

            </summary>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.FontData.FontMapNames">

            <summary>

            The list of the names of font maps where all characters are stored.

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.FontData.FontDataTests">

            <summary>

            Tests

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.FontDataTests.GetTestFont">

            <summary>

            Get font data which is used for all tests where the tests values are

            tweaked for.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.FontDataTests.LoadDefaultFontData">

            <summary>

            Load default font data

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.FontDataTests.ParseTextLines">

            <summary>

            Parse text lines

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.FontDataTests.GetTextLines">

            <summary>

            Get text lines

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.FontDataTests.GetTextlineWrapped">

            <summary>

            Get text line wrapped

            </summary>

            Caution: For this unit test are the following modules required:

            - Graphic

            - Platforms.IWindow

            - ContentManager.Client

        </member>

        <member name="M:Delta.ContentSystem.Rendering.FontData.FontDataTests.GetGlyphDrawInfos">

            <summary>

            Get glyph draw infos

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.ModelData">

            <summary>

            Model data class, which combines a list of meshes and a list of mesh

            animations. Because models can have multiple meshes and animations they

            should be used for more complex 3d data. If you only need a static mesh

            just use the Mesh class, which is better optimized and can be used for

            level geometry with lots of extra optimizations and mesh merging than

            possibly than rendering everything as models.

            <para />

            Please note that Models just contain meshes and animations and have no

            data own their own (just meta data).

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ModelData.Get(System.String)">

            <summary>

            Get and load content based on the content name. This method makes sure

            we do not load the same content twice (the constructor is protected).

            </summary>

            <param name="contentName">Content name we want to load, this is

            passed onto the Content System, which will do the actual loading with

            help of the Load method in this class.</param>

            <returns>The loaded Content object, always unique for the same

            name, this helps comparing data.</returns>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.ModelData.Meshes">

            <summary>

            List of meshes to be used for this model. Often is just one mesh.

            Please note that we also will load and link up the animations inside

            of each mesh (see load method below), this way it is easier to manage.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ModelData.#ctor">

            <summary>

            Create model data object with no data in it. Just add stuff to the

            Meshes and Animations fields.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ModelData.#ctor(System.String)">

            <summary>

            Create mesh animation data by loading it from content, see Load below.

            Use the static Get method to call this.

            </summary>

            <param name="contentName">Name of the content.</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ModelData.ToString">

            <summary>

            To string, will display the model name with the meshes in it (plus

            optionally their animations if they have those).

            </summary>

            <returns>

            A <see cref="T:System.String"/> that represents this ModelData

            instance with the list of mesh names.

            </returns>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.ModelData.Load(Delta.ContentSystem.Content)">

            <summary>

            Native load method, will just load meshes and animations contained in

            this content type (models have no data on their own).

            </summary>

            <param name="alreadyLoadedNativeData">Ignored here, can't be cloned.

            </param>

        </member>

        <member name="P:Delta.ContentSystem.Rendering.ModelData.InitialScale">

            <summary>

            Provides the initial scale value as provided by the content meta data.

            Usually 1.0f, which means rendering is done normally. If this value is

            different the content model will be scaled accordingly (should rarely

            be needed, scaling has obviously performance impacts, it is currently

            also ignored for most content types including meshes).

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.Helpers.Glyph">

            <summary>

            Info for each glyph in the font, used for FontData to store all glyph

            data. Glyphs are characters and their information on where it is found

            in a texture, only needed in the Font and FontGenerator classes.

            </summary>

            <remarks>

            Based on Benjamin Nitschke's older BitmapFont class for XNA,

            which was based on the XNAExtras project from Gary Kacmarcik

            (garykac@microsoft.com), more information can be found at:

            http://blogs.msdn.com/garykac/articles/749188.aspx

            If you want to know more details about creating bitmap fonts in XNA,

            how to generate the bitmaps and more details about using it, please

            check out the following links:

            http://blogs.msdn.com/garykac/archive/2006/08/30/728521.aspx

            http://blogs.msdn.com/garykac/articles/732007.aspx

            http://www.angelcode.com/products/bmfont/

            </remarks>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.Glyph.FontMapId">

            <summary>

            Font map number (starts with 0) in case we need multiple images for

            this font (the bigger the font is and the more characters we got in

            there, the more important this gets). Links to the materialList in

            the Font class (which loads the font maps via the Material, which has

            images that are loaded from our font maps)!

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.Glyph.UV">

            <summary>

            TODO: Change description

            UV Rectangle (in Pixels) used for drawing this character. Includes

            the position and size obviously. We should not use atlas textures

            because fonts are already atlases and we can directly use this UVs

            for drawing.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.Glyph.AdvanceWidth">

            <summary>

            Advance width (in pixels) for this character. This is the ruff offset

            we have to move to the right after drawing the character. The

            precise width has to be calculated with this the glyph distance from

            the kerning (see the Font class).

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.Glyph.LeftSideBearing">

            <summary>

            Left side bearing (in pixels) is used to offset this character to the

            left. This means that rendering starts earlier than the currently

            specified pixel position to make sure the text looks right on the

            screen. Often unused and just 0, but sometimes has negative values.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.Glyph.RightSideBearing">

            <summary>

            Right side bearing (in pixels) is used to offset this character to the

            right. This means that rendering starts earlier than the currently

            specified pixel position to make sure the text looks right on the

            screen. Often unused and just 0, but sometimes has negative values.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.Glyph.FontMapUV">

            <summary>

            TODO: Change description

            Precomputed font map UVs. Not stored in the Xml font file because we

            can easily generate them at load time (just divide the UV by the image

            size).

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.Glyph.Kernings">

            <summary>

            That dictionary contains the amount of extra distances offsets between

            the current character to any other one. But usually there are only some

            few cases like combinations with 'W', 'I', and other big or small

            glyph's. Mostly the is no need for an extra distance offset to other

            characters.

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.Glyph.GetDrawWidth(System.Char,System.Single)">

            <summary>

            Gets the (to fully pixel rounded) drawing width of the glyph based on

            the previous one.

            </summary>

            <param name="nextChar">Next char</param>

            <param name="trackingPercentage">Tracking percentage</param>

            <returns>Draw width</returns>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.Helpers.BoneData">

            <summary>

            Helper class to store one bone entry for animated 3D models,

            this is not directly a content class, but used for MeshData and is

            also important for AnimationData, which keeps all the animated matrices.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.BoneData.CurrentVersion">

            <summary>

            Version number for this MeshData. If this goes above 1, we need

            to support loading older versions as well. Saving is always going

            to be the latest version (this one).

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.BoneData.Id">

            <summary>

            Id

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.BoneData.Name">

            <summary>

            Name

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.BoneData.InverseTransformMatrix">

            <summary>

            The inverse bone skin matrix

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.BoneData.ParentId">

            <summary>

            Parent id

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.BoneData.ChildrenIds">

            <summary>

            Children ids

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.BoneData.#ctor">

            <summary>

            Create bone data

            </summary>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.BoneData.#ctor(System.IO.BinaryReader)">

            <summary>

            Create bone data

            </summary>

            <param name="dataReader">Data reader</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.BoneData.Load(System.IO.BinaryReader)">

            <summary>

            Load bone data (mostly all the matrices and their relationship).

            </summary>

            <param name="reader">Reader</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.BoneData.Save(System.IO.BinaryWriter)">

            <summary>

            Save bone date (mostly all the matrices and their relationship).

            </summary>

            <param name="dataWriter">Data writer</param>

        </member>

        <member name="M:Delta.ContentSystem.Rendering.Helpers.BoneData.ToString">

            <summary>

            To string

            </summary>

        </member>

        <member name="T:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames">

            <summary>

            Defines the names of all uniforms that we support (with properties) in

            all shaders by the directly by the engine. Every else uniform needs to

            be handled by the project code itself. Please note that most shaders

            are very simple and only have very few pixel shader instructions

            because we need to optimize as much as possible on most mobile

            devices. There are some complex shaders however for special effects,

            skinning, water, fog or even using multiple lights or shadow mapping.

            On faster hardware these can be used to archive great effects.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.World">

            <summary>

            Global matrices, important for transforming vertices in the vertex

            shader. We only use optimized matrices, more are not supported!

            Set in Set2DRenderMatrix and Set3DRenderMatrix.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.ViewInverse">

            <summary>

            Global matrices, important for transforming vertices in the vertex

            shader. We only use optimized matrices, more are not supported!

            Set in Set2DRenderMatrix and Set3DRenderMatrix.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.WorldViewProj">

            <summary>

            Global matrices, important for transforming vertices in the vertex

            shader. We only use optimized matrices, more are not supported!

            Set in Set2DRenderMatrix and Set3DRenderMatrix.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.SkinnedMatrices">

            <summary>

            For skinned meshes, this are all the bone matrices, which are

            updated by the app for each animated meshes and will be applied to

            all skinned vertices in the vertex shader (if shaders are possible).

            Set in Set3DRenderMatrix.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.Time">

            <summary>

            Time for animated shaders, rarely used however. Also set in

            Set2DRenderMatrix and Set3DRenderMatrix.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.DiffuseMap">

            <summary>

            All the material data. Please note that many of these are not used

            in most shaders, e.g. DirectionalTextured just has DiffuseMap and

            the LightDirection plus global matrices, that's it, the rest is

            constant! It is faster and easier to merge materials if the shader

            uses constants and thus all materials rendered with them are

            basically the same, they only differ in the DiffuseMap, which is

            quickly checked.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.DetailMap">

            <summary>

            Detail map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.SpecularMap">

            <summary>

            Specular map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.HeightMap">

            <summary>

            Height map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.NormalMap">

            <summary>

            Normal map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.LightMap">

            <summary>

            Light map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.SkyCubeMap">

            <summary>

            Sky cube map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.ReflectionCubeMap">

            <summary>

            Reflection cube map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.ShaderLutTexture">

            <summary>

            Shader lut texture for optimizations

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.ShadowMap">

            <summary>

            Shadow map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.AmbientColor">

            <summary>

            Global ambient color.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.DiffuseColor">

            <summary>

            Diffise color.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.DirectionalLightDirection">

            <summary>

            Extra data for light shaders, this usually slows down pixel shaders

            a lot, so mobile shaders rarely use direct lighting. Instead we try

            to use a directional light source and light maps as much as possible.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PointLightPosition">

            <summary>

            Point lights have a position and a radius, optionally also a color.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PointLightRadius">

            <summary>

            Point lights have a position and a radius, optionally also a color.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PointLightColor">

            <summary>

            Point lights have a position and a radius, optionally also a color.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PointLightTwoPosition">

            <summary>

            We support 0-2 lights, but this is very rare. For more lights,

            choose the 2 most dominant ones, ignore the rest or if you are

            really nice, fade them out as you get closer to other light sources.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PointLightTwoRadius">

            <summary>

            We support 0-2 lights, but this is very rare. For more lights,

            choose the 2 most dominant ones, ignore the rest or if you are

            really nice, fade them out as you get closer to other light sources.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PointLightTwoColor">

            <summary>

            We support 0-2 lights, but this is very rare. For more lights,

            choose the 2 most dominant ones, ignore the rest or if you are

            really nice, fade them out as you get closer to other light sources.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PostScreenWindowSize">

            <summary>

            Extra uniforms for post screen shaders, render-to-texture window size

            and the resulting texture are required for all post screen shaders.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PostScreenMap">

            <summary>

            Post screen map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PostScreenBorderFadeoutMap">

            <summary>

            For the last pass we can add this fadeout map to darken the borders

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.PostScreenNoiseMap">

            <summary>

            Noise map

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.ShadowMapTransform">

            <summary>

            For shadow mapping we got some extra uniforms. These are only used

            for shadow mapping algorithms, which is a huge pixel cost for older

            mobile devices. There stencil shadows or fake shadow blobs make

            usually more sense, however shadow mapping often looks better.

            Transformation matrix for converting world position to texture

            coordinates of the shadow map.

            </summary>

        </member>

        <member name="F:Delta.ContentSystem.Rendering.Helpers.ShaderUniformNames.ShadowMapLightWorldViewProj">

            <summary>

            WorldViewProj of the light projection for shado