/Dlls/Delta.Utilities.Graphics.xml

<?xml version="1.0"?>

<doc>

    <assembly>

        <name>Delta.Utilities.Graphics</name>

    </assembly>

    <members>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature">

            <summary>

            Skinning shader feature

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.IShaderFeature">

            <summary>

            Interface for all ShaderFeatures.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.IShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.IShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.IShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature.#ctor">

            <summary>

            Create skinning shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create skinning shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.UseSkinningShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature">

            <summary>

            Fresnel shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.FresnelPower">

            <summary>

            Fresnel power.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.FresnelFactor">

            <summary>

            Fresnel factor.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.#ctor">

            <summary>

            Create fresnel shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create fresnel shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.FresnelShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature">

            <summary>

            Fog shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.FogColor">

            <summary>

            The ShaderParameters array should contain: FogColor, FogStart and

            FogEnd. This does not mean those variables are used as shader uniforms,

            they are usually constant and can be used for both fixed function

            pipeline code and for shader code. Adds 4-5 vertex shader instructions

            and 2 pixel shader instructions (lerp is costly, but required).

            Note: Currently only the FogColor is used in the shader, the rest

            is baked as constants into it (faster because we don't need to

            calculate FogEnd-FogStart and it makes more sense to have the same

            values for all shaders anyway).

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.FogStart">

            <summary>

            The default fog start distance is 10m, everything closer will also

            get a little of the FogColor, see MinimumFogValue.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.FogEnd">

            <summary>

            Maximum distance for the fog, here the fog is at full intensity (see

            MaximumFogValue). Should be synced up with BaseCamera.FarPlane, which

            is currently 75.0 for the SoulCraft Tech Demo.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.MinimumFogValue">

            <summary>

            Minimum fog value that gets mixed in for each pixel in the pixel

            shader. This value is currently pretty high (0.15 like the default

            ambient color) to color all pixels a little in the fog color to

            colorize everything in the scene with this fog color to fit together

            better.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.MaximumFogValue">

            <summary>

            Maximum fog value, does not have to be 1.0, the default value for

            this is 0.9, which means fog is never at 100%. There will always be

            a little bit of the original pixel shader color visible.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.#ctor">

            <summary>

            Create fog shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create fog shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.FogShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature">

            <summary>

            ParallaxMap shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.ParallaxAmount">

            <summary>

            Parallax mapping is usually used in combination with normal mapping,

            but you can use it own its own. It needs an extra height map (usually

            just the light map or normal map extra alpha color channel) for even

            cooler depth effects on the texture. Adds about 2 instructions, but

            even if that overhead is ok, also additional work at the artist side

            is needed, not only to create the extra height/bump map, but also to

            fine tune the parallax amount to look nice. The height map should be

            as blurry as possible, high variations will cause parallax glitches.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.#ctor">

            <summary>

            Create parallax shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create parallax shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.ParallaxMapShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature">

            <summary>

            Water shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature.#ctor">

            <summary>

            Create water shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create water shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.WaterShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature">

            <summary>

            Dynamic directional lighting shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.DirectionalLightDirection">

            <summary>

            Direction of the directional light.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.#ctor">

            <summary>

            Create basic shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create basic shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.DynamicDirectionalLightingShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature">

            <summary>

            Basic shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.DiffuseMap">

            <summary>

            Diffuse map, is always set except when ShaderFeatureFlags.NoTexturing

            is set (then we don't want a diffuse map and this setting is ignored).

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.#ctor">

            <summary>

            Create basic shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create basic shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.BasicShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature">

            <summary>

            Light map shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.LightMap">

            <summary>

            LightMap, is always set except when ShaderFeatureFlags.NoTexturing is

            set (then we don't want a diffuse map and this setting is ignored).

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.#ctor">

            <summary>

            Create light map shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create light map shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.LightMapShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature">

            <summary>

            Detail mapping shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.DetailMap">

            <summary>

            The Detail map is a tiled texture that is added to improve the sharpness

            especially in highly scaled textures. There is a texture on which a 

            fine pattern is shown (usually this is a "noise" effect used). 

            The Detail map is tiled over the terrain and this combined with a 

            diffuse mal or color map.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.#ctor">

            <summary>

            Create detail map shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create detail map shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.DetailMappingShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ColorBufferMode">

            <summary>

            Platform color buffer for a device. Usually RGB565 for mobile devices

            and RGBA8888 for PCs and Consoles. RGBAFloat16 or RGBAFloat32 can also

            be used for high profile PC or Console games.

            <para />

            Note: Exotic modes like RGBA4444, RGBA5551, RGB888, or RGB10A2 are not

            supported right now.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ColorBufferMode.RGB565">

            <summary>

            16 bit color display bit depth. This means less colors can be displayed

            and more jaggy steps between darker and brighter shaders of the same

            color are visible. Clever artists can circumvent that by using not

            so many shades, using dither effects or have a overall more comic or

            solid color look. This is the default color depth for most mobile

            devices. Except for the iPad2 and the iPhone4 almost all of them

            only support 16 bit colors at the display anyway. For example check

            out: http://www.obsessable.com/cell-phone/apple-iphone-3g/specs/

            So using 24 or 32 bit for your frame buffer will not result in any

            better output, just worse performance. Red channel = 5 bits, Green

            channel = 6 bits and Blue channel = 5 bits. Some texture generation

            rules might also be aware of this setting and reduce or optimize

            quality to fit the output format.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ColorBufferMode.RGBA8888">

            <summary>

            32 bit color display bit depth. Usually only the RGB components are

            important so this color mode is usually called 24 bit because the

            last 8 bits are unused. Quality is a lot better than 16 bit, but

            since this is twice as many bits, it needs twice the memory bandwidth.

            Faster platforms have this as their default, which is even faster for

            them because memory bandwidth is not a big issue and converting to

            16 bit can even slow you down. For slower and older mobile devices

            and especially devices that can only do 16 bit on the display anyway,

            it is much better to choose 16 bit. A developer can choose this bit

            depth if he wants more quality on devices where it makes a difference

            if he still has enough performance.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ColorBufferMode.RGBAFloat16">

            <summary>

            Special mode for 16-bit floating point RGBA frame buffers, 16 bit

            float is also called half-float. Total size is 64 bit. Screens usually

            only have 24 bits or even only 18 bits (3*6 bits), so this mode only

            makes sense for HDR cases and high performance platforms.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ColorBufferMode.RGBAFloat32">

            <summary>

            Special mode for 32-bit floating point RGBA frame buffers. Total size

            is 128 bit. Screens usually only have 24 bits or even only 18 bits

            (3*6 bits), so this mode only makes sense for HDR cases and high

            performance platforms.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.BlendMode">

            <summary>

            Blending presets are used for setting alpha blending operations of

            various types for producing different effects. Now set directly

            in materials because we want to sort them by blend mode too :)

            Note: Needed in Content modules already because atlas textures

            need to know about the blend modes!

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.BlendMode.Opaque">

            <summary>

            The default preset is opaque, which is the fastest blending type

            because it uses no blending obviously. Also works with AlphaTesting,

            which is decided once a material is created (then an AlphaTest shader

            will be chosen). This blend state is the default for all materials

            that have no alpha channel in the diffuseMap!

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.BlendMode.AlphaTest">

            <summary>

            Same as opaque, but use AlphaTest to discard any pixel below 0.66f

            in the alpha channel. Rendering this is faster than Translucency

            because we need no sorting and we can skip lots of pixels, which

            makes the pixel shader go faster. This is however not always true for

            mobile GPUs as discard is sometimes as expensive as actual rendering!

            Still this is a useful feature to not write to the depth buffer for

            transparent pixels thus helping with sorting.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.BlendMode.Subtractive">

            <summary>

            Subtractive rendering mode is pretty much the opposite of additive

            blending. Instead of always adding more brightness to the target

            screen pixels, this one subtracts brightness. It is usually and

            mostly only used for fake shadowing effects (blob shadows) and

            sometimes in clever combinations of particle effects.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.BlendMode.Additive">

            <summary>

            Additive blending is used to accumulate the color we already got

            on screen plus the diffuseMap * AmbientColor. This makes the result

            image brighter and should be used with care. Has the advantage that

            we do not need to sort, we can just render this out in any order

            on top of the Opaque materials and it will always look the same.

            This blend state usually has to be set by hand to a material!

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.BlendMode.Translucency">

            <summary>

            The normal version of alpha blending, which uses ambientColor.A *

            diffuseMap alpha and blends that with SrcAlpha InvDestColor (default

            alpha blending technique). This blend mode is the default for

            all materials that have an alpha channel in diffuseMap!

            Note: Only translucent images with alpha should use this blend mode.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.BlendMode.LightEffect">

            <summary>

            LightEffect, which is using a special blend mode of DestColor+One,

            which will maybe change later a bit. Basically used for light effects

            (similar to lightmap shader, but just using a lightmap, no diffuse

            texture). Needs to set by hand for lightmap materials, only a couple

            of materials even need to use this, e.g. glow, light and flare effects.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature">

            <summary>

            Use shadow map shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature.#ctor">

            <summary>

            Create a shader feature for using shadow maps.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create basic shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.UseShadowMapShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature">

            <summary>

            Specular diffuse shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature.#ctor">

            <summary>

            Create specular diffuse shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create specular diffuse shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.SpecularDiffuseShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature">

            <summary>

            No texture shader feature. This is just used to disable texturing,

            which is on by default (via BasicShaderFeature).

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature.#ctor">

            <summary>

            Create basic shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create basic shader feature and load automatically

            the ShaderFeatures from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.NoTexturingShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature">

            <summary>

            Specular shader feature

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.SpecularColor">

            <summary>

            Specular color is the color of highlights on a shiny surface. 

            The highlights are reflections of the lights that illuminate the 

            surface. For a naturalistic effect, set the specular color to the 

            same color as the key light source, or make it a high-value, 

            low-saturation version of the diffuse color.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.SpecularPower">

            <summary>

            A specular power refers to how much light is reflected in a mirror 

            like fashion, rather than scattered randomly in a diffuse manner. 

            So a mirror would have high specular power, a glossy surface some 

            specular power and a matt black surface none.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.#ctor">

            <summary>

            Create specular shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.#ctor(System.IO.BinaryReader)">

            <summary>

            Create specular shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.Load(System.IO.BinaryReader)">

            <summary>

            Load this ShaderFeature from a binary data stream.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.Save(System.IO.BinaryWriter)">

            <summary>

            Save this ShaderFeature to a binary data stream.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.ShaderFeature">

            <summary>

            Which shader feature flag is this ShaderFeature class using?

            Important for loading this file via ShaderData.LoadShaderFeature.

            Each flag should obviously only have one class for it!

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.RequiredShaderFeatures">

            <summary>

            Which shader feature flags are required for this ShaderFeature.

            Very important for creating of a new ShaderFeature.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.ShaderFeatures.SpecularShaderFeature.Parameters">

            <summary>

            Parameters as a dictionary, will be generated on the fly when

            requested.

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants">

            <summary>

            Shader constants, not only needed for the Content and as default values

            for the shader classes in Graphics, but also for the default fallback

            values for many of the shader feature classes in this namespace.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultSpecularPower">

            <summary>

            Default specular power (4 now for better fresnel, was 24 before)

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultFresnelPower">

            <summary>

            Default 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.

            Note: Now in a pre-calculated lut texture, not longer a parameter!

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultFresnelFactor">

            <summary>

            Default fresnel factor. Fresnel * FresnelFactor.

            Note: Now in a pre-calculated lut texture, not longer a parameter!

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultParallaxAmount">

            <summary>

            Default parallax offset amount in pixels for a 1024x1024 texture.

            16 means that we will offset -16 to +16 pixels in the texture (which

            is a lot, you really need smooth transitions to make this look ok).

            Note: For a 2048x2048 texture it would be -32 to +32 pixels, for

            a 512x512 texture it would be -8 to +8 because the formula is always

            the same: 1024.0 / ParallaxAmount. Note: Increased a bit to 27.0f

            because now it is only used on floors, old value: 16.0f.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultMinAmbientValue">

            <summary>

            Minimum ambient value.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultAlphaTestValue">

            <summary>

            Value for alpha test.

            The default value is normally 0.66.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultFogStart">

            <summary>

            Default fog start.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultFogEnd">

            <summary>

            Fog end.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultMaxFogValue">

            <summary>

            Maximum fog value.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultMinFogValue">

            <summary>

            Minimum fog value.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.MaxBonesCount">

            <summary>

            Maximal bones count that we can support currently = 36.

            But you can change that value dynamically via the Content Settings :)

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultAmbientColor">

            <summary>

            Default colors are 0.15 for ambient and 1.0 for diffuse and specular.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultDiffuseColor">

            <summary>

            Default diffuse color is almost white (90%)

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultSpecularColor">

            <summary>

            Default specular color is always white

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultFogColor">

            <summary>

            Default fog color. 133, 37, 12 + 0.075 brightness

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultShadowSize">

            <summary>

            Default shadow size. Normally 512x512. The size is useful to get 

            the pixel size in shader (1.0 / 512.0).

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.ShaderFeatures.ShaderConstants.DefaultShadowColor">

            <summary>

            Default shadow color. Using for the shadow map generation.

            0.33 is pretty dark (0.5 is too weak however), 0.0 is black and

            will usually not look very well for bright scenes (only in Doom3 ^^)

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.FontStyle">

            <summary>

            Font style for the font creation process, allows us to add shadow

            to the font, create an outline, use italic or bold text plus

            specifying anti aliasing. Combine these with or and pass them to

            FontGenerator.GenerateFont, but also used for creating and loading

            fonts to make sure we got the correct style.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.Normal">

            <summary>

            Normal is probably used by most fonts, just renders the font out

            and uses anti aliasing, no bold, no italic, no shadow and no outline.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.Italic">

            <summary>

            Use italic (works only if the font has it), not used often.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.Bold">

            <summary>

            Make font bold (works only if font supports this).

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.Underline">

            <summary>

            Add underline to the font (works only if font supports this).

            Note: This may look strange with some other effects (like shadow or

            outline) because this is not supported well and probably needs some

            fixing when rending the font.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.AddShadow">

            <summary>

            Add shadow to the font, usually makes the font a little bigger

            to fit the shadow (which is just the font again painted in black

            with a 10% distance into the bottom right, rendered before the

            actual white font).

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.AddOutline">

            <summary>

            Add a black outline to the font, currently does not work well,

            especially for big fonts. Small fonts look ok. This will add some

            spacing (2px) around the font to allow an artist to add outlines

            himself if he isn't pleased with the generated texture.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.HighContrast">

            <summary>

            Increase the contrast of the font rendering to its maximum value.

            This can be used the font is too blurry otherwise. Should not be

            used with NoAntiAliasing, this would not affect SingleBitPerPixel.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.LowContrast">

            <summary>

            Decrease the contrast to a very low setting to make the font look

            more smooth. You should only use this for big fonts and if you think

            the font is too sharp. Should not be used with NoAntiAliasing,

            this would not affect SingleBitPerPixel rendering.

            Do not use together with HighContrast, then this setting will be

            ignored.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.ClearTypeAntiAliasing">

            <summary>

            Instead of using the default anti aliasing (which uses

            TextRenderingHint.AntiAliasGridFit) use

            TextRenderingHint.ClearTypeGridFit, which might produce slightly

            different results depending if the font and system support

            clear type. Sometimes produces less sharp fonts so this is not the

            default and the difference can usually be neglected.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.FontStyle.NoAntiAliasing">

            <summary>

            Disable anti aliasing (uses TextRenderingHint.SingleBitPerPixel),

            should not be necessary, even small fonts look ok with anti aliasing.

            Note: Do not use together with ClearTypeAntiAliasing, then

            this setting will be ignored (then Clear Type Anti aliasing will be

            still on, this only disables the default Anti aliasing).

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.VertexElement">

            <summary>

            Vertex element, defines the type of a vertex element, if it is

            compressed and the size occupied. See VertexFormat for details.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.MaxCompressedVertexDistance">

            <summary>

            The max. distance (in meters) that a vertex may be distant from the

            coordinate origin (because of mobile vertex compression). When

            importing 3D models this is checked and a warning will be shown if a

            vertex is farther away from the origin than 300m.

            See Position3DCompressionValue for the formula.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.Position3DCompressionValue">

            <summary>

            When converting vertex positions to shorts to store them into

            Position3DCompressed this formula is used (1/436.0f). The minimum

            resulting 3D position is -75.0f and the maximum is 75.0f. Everything

            beyond that cannot be represented as Position3DCompressed shorts, but

            since most models are only a few meters in size this should be no

            problem.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.Position2DCompressionValue">

            <summary>

            When converting vertex positions to shorts to store them into

            Position2DCompressed this formula is used (1/16384). The minimum

            valid value for shorts is -32767, divided through this constant this

            is -2.0f, the maximum value is 32768, which is +2.0f.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.ShortCompressionValue">

            <summary>

            For TextureUVCompressed we just use a simple 1/32767 formula, since

            we will only accept UVs between 0 and 1 anyway. This precision is also

            good for the bigger atlas textures we might have (up to 2k/2k).

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.SignedByteCompressionValue">

            <summary>

            For normals, tangents and binormals (colors are not normalized, they

            won't need any compression, we can just use the bytes values from

            our Color struct). So only for normalized values we use a simple

            compression formula: value * 127

            Decompress formula: value / 127

            The formula is only for values between -1 and +1.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.OpenGLPositionAttribute">

            <summary>

            OpenGL attributes are used for the shader generation and for getting

            of the attributes to set them.

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.OpenGLTexCoordAttribute">

            <summary>

            Open GL tex coord attribute

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.OpenGLNormalAttribute">

            <summary>

            Open GL normal attribute

            </summary>

        </member>

        <member name="F:Delta.Utilities.Graphics.VertexElement.OpenGLTangentAttribute">

            <summary>

            Open GL tangent attribute

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.#ctor(Delta.Utilities.Graphics.VertexElementType)">

            <summary>

            Create vertex element of a specific type. If we are on the iPhone,

            Android or WP7 compression should be used with the other constructor

            for vertex elements to save bandwidth and make rendering much faster.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.#ctor(Delta.Utilities.Graphics.VertexElementType,System.Boolean)">

            <summary>

            Create vertex element, this constructor forces compression if wanted.

            This is usually controlled by the content and build system on the

            server side (important for iPhone, Android, WP7 to save bandwith and

            improve rendering performance).

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.Load(System.IO.BinaryReader)">

            <summary>

            Load

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.Save(System.IO.BinaryWriter)">

            <summary>

            Save

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.LoadData(System.IO.BinaryReader)">

            <summary>

            Extract value as a Vector, not very efficient, but always works :)

            </summary>

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

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.LoadDataAsPoint(System.IO.BinaryReader)">

            <summary>

            Extract value as a Point, not very efficient, but always works :)

            </summary>

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

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.SaveData(System.IO.BinaryWriter,Delta.Utilities.Datatypes.Vector)">

            <summary>

            Save data helper method for GeometryData.SetVertexData, which is slow,

            but still helpful for debugging and creating geometry dynamically.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.SaveData(System.IO.BinaryWriter,Delta.Utilities.Datatypes.Point)">

            <summary>

            Save data helper method for GeometryData.SetVertexData, which is slow,

            but still helpful for debugging and creating geometry dynamically.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.SaveData(System.IO.BinaryWriter,Delta.Utilities.Datatypes.Color)">

            <summary>

            Save data helper method for GeometryData.SetVertexData, which is slow,

            but still helpful for debugging and creating geometry dynamically.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.ToString">

            <summary>

            To string

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.SetupProperties">

            <summary>

            Get size, component count, vertex data format and if this vertex data

            needs to be normalized (for compressed data).

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.Position3DCompress(System.Single)">

            <summary>

            Short compression is only for values between -75.0 and +75.0.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.Position2DCompress(System.Single)">

            <summary>

            Position 2D compression

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.ShortCompress(System.Single)">

            <summary>

            Short compression is only for values between -1.0 and +1.0.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.SignedByteCompress(System.Single)">

            <summary>

            Byte compression is only for normalized values between -1.0 and +1.0.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.Position3DDecompress(System.Int16)">

            <summary>

            Decompress a short value to a float.

            Return min value: -75.0

            Return max value: +75.0

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.Position2DDecompress(System.Int16)">

            <summary>

            Position 2D decompress

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.ShortDecompress(System.Int16)">

            <summary>

            Short decompression.

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.SignedByteDecompress(System.SByte)">

            <summary>

            Decompress a byte value to a float (for normals, tangents, etc.)

            Return min value: -1.0

            Return max value: +1.0

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.Type">

            <summary>

            Type for this vertex element (position, uv, etc.)

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.IsCompressed">

            <summary>

            Is this vertex element compressed? Usually true for iPhone, Android

            and WP7 to save bandwidth (about half), but some vertex format types

            like color and skin data are already compressed and cannot be more

            compact. Most VertexFormats like Position2DTexture really get much

            smaller with compressed on (down to 10 bytes from 20 uncompressed).

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.Size">

            <summary>

            Size in bytes of this vertex element. Used to find the offset for the

            next element mostly and for the total vertex size in bytes of course.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.Offset">

            <summary>

            Offset from the start of the vertex data to this element in bytes.

            Calculated in VertexFormat constructor.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.ComponentCount">

            <summary>

            Returns the number of components of that element.

            E.g. Color = 4, Vector (Position, Normal) = 3, Point (UV) = 2.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.IsNormalized">

            <summary>

            Is normalized? Currently used for compressed Texture UVs, Normals,

            Tangents, Color and SkinWeights. This is used to save bandwidth

            because compressed vertex data is smaller, but needs to be normalized

            usually (except when we account for it in the shader like for

            position vertex data via the World or WorldViewProj matrices).

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.IsByteFormat">

            <summary>

            Is byte format? Currently only used for colors. Use IsSignedByteFormat

            for normals, tangents and binormals.

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.IsSignedByteFormat">

            <summary>

            Is signed byte format? Only used for normals, tangents, binormals.

            Colors use IsByteFormat (unsigned).

            </summary>

        </member>

        <member name="P:Delta.Utilities.Graphics.VertexElement.IsShortFormat">

            <summary>

            Is short format? Used mostly for compressed vertex data. If this

            and IsByteFormat are false the vertex element components are floats!

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.VertexElement.VertexElementTests">

            <summary>

            Tests

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.VertexElement.VertexElementTests.GetSize">

            <summary>

            Get size

            </summary>

        </member>

        <member name="T:Delta.Utilities.Graphics.ShaderFeatures.UI2DShaderFeature">

            <summary>

            UI2D shader feature

            </summary>

        </member>

        <member name="M:Delta.Utilities.Graphics.ShaderFeatures.UI2DShaderFeature.#ctor">